blob: eb133cd9f9186e19b114625e7174d7a1916960b0 [file] [log] [blame]
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001/*
2 * Copyright © 2008 Kristian Høgsberg
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
Kristian Høgsberg0b36d972013-08-21 22:13:17 -070023#include <config.h>
Peng Wucfcc1112013-08-19 10:59:21 +080024
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +020025#include <stdbool.h>
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050026#include <stdint.h>
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include <fcntl.h>
31#include <unistd.h>
32#include <math.h>
33#include <time.h>
Kristian Høgsberg269d6e32008-12-07 23:17:31 -050034#include <pty.h>
Kristian Høgsbergf04e8382008-12-08 00:07:49 -050035#include <ctype.h>
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050036#include <cairo.h>
Kristian Høgsberg3a696272011-09-14 17:33:48 -040037#include <sys/epoll.h>
Peng Wucfcc1112013-08-19 10:59:21 +080038#include <wchar.h>
39#include <locale.h>
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050040
Kristian Høgsberg67b82152013-10-23 16:52:05 -070041#include <linux/input.h>
42
Pekka Paalanen50719bc2011-11-22 14:18:50 +020043#include <wayland-client.h>
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050044
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -040045#include "../shared/config-parser.h"
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050046#include "window.h"
47
Kristian Høgsberg0395f302008-12-22 12:14:50 -050048static int option_fullscreen;
Kristian Høgsberg9c3dee12013-09-21 22:23:08 -070049static char *option_font;
50static int option_font_size;
51static char *option_term;
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -040052static char *option_shell;
53
54static struct wl_list terminal_list;
55
56static struct terminal *
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -040057terminal_create(struct display *display);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -040058static void
59terminal_destroy(struct terminal *terminal);
60static int
61terminal_run(struct terminal *terminal, const char *path);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050062
Peng Wuf291f202013-06-06 15:32:41 +080063#define TERMINAL_DRAW_SINGLE_WIDE_CHARACTERS \
64 " !\"#$%&'()*+,-./" \
65 "0123456789" \
66 ":;<=>?@" \
67 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
68 "[\\]^_`" \
69 "abcdefghijklmnopqrstuvwxyz" \
70 "{|}~" \
71 ""
72
Kristian Høgsberg6e83d582008-12-08 00:01:36 -050073#define MOD_SHIFT 0x01
74#define MOD_ALT 0x02
75#define MOD_CTRL 0x04
76
Callum Lowcay30eeae52011-01-07 19:46:55 +000077#define ATTRMASK_BOLD 0x01
78#define ATTRMASK_UNDERLINE 0x02
79#define ATTRMASK_BLINK 0x04
80#define ATTRMASK_INVERSE 0x08
Callum Lowcay81179db2011-01-10 12:14:01 +130081#define ATTRMASK_CONCEALED 0x10
Callum Lowcay30eeae52011-01-07 19:46:55 +000082
Callum Lowcayb8609ad2011-01-07 19:46:57 +000083/* Buffer sizes */
Callum Lowcayef57a9b2011-01-14 20:46:23 +130084#define MAX_RESPONSE 256
85#define MAX_ESCAPE 255
Callum Lowcayb8609ad2011-01-07 19:46:57 +000086
Callum Lowcay8e57dd52011-01-07 19:46:59 +000087/* Terminal modes */
88#define MODE_SHOW_CURSOR 0x00000001
89#define MODE_INVERSE 0x00000002
90#define MODE_AUTOWRAP 0x00000004
91#define MODE_AUTOREPEAT 0x00000008
92#define MODE_LF_NEWLINE 0x00000010
Callum Lowcay69e96582011-01-07 19:47:00 +000093#define MODE_IRM 0x00000020
Callum Lowcay7e08e902011-01-07 19:47:02 +000094#define MODE_DELETE_SENDS_DEL 0x00000040
95#define MODE_ALT_SENDS_ESC 0x00000080
Callum Lowcay8e57dd52011-01-07 19:46:59 +000096
Callum Lowcay15bdc5d2011-01-07 19:46:54 +000097union utf8_char {
98 unsigned char byte[4];
99 uint32_t ch;
100};
101
102enum utf8_state {
103 utf8state_start,
104 utf8state_accept,
105 utf8state_reject,
106 utf8state_expect3,
107 utf8state_expect2,
108 utf8state_expect1
109};
110
111struct utf8_state_machine {
112 enum utf8_state state;
113 int len;
114 union utf8_char s;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700115 uint32_t unicode;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000116};
117
118static void
119init_state_machine(struct utf8_state_machine *machine)
120{
121 machine->state = utf8state_start;
122 machine->len = 0;
123 machine->s.ch = 0;
124}
125
126static enum utf8_state
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -0400127utf8_next_char(struct utf8_state_machine *machine, unsigned char c)
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000128{
129 switch(machine->state) {
130 case utf8state_start:
131 case utf8state_accept:
132 case utf8state_reject:
133 machine->s.ch = 0;
134 machine->len = 0;
135 if(c == 0xC0 || c == 0xC1) {
136 /* overlong encoding, reject */
137 machine->state = utf8state_reject;
138 } else if((c & 0x80) == 0) {
139 /* single byte, accept */
140 machine->s.byte[machine->len++] = c;
141 machine->state = utf8state_accept;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700142 machine->unicode = c;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000143 } else if((c & 0xC0) == 0x80) {
144 /* parser out of sync, ignore byte */
145 machine->state = utf8state_start;
146 } else if((c & 0xE0) == 0xC0) {
147 /* start of two byte sequence */
148 machine->s.byte[machine->len++] = c;
149 machine->state = utf8state_expect1;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700150 machine->unicode = c & 0x1f;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000151 } else if((c & 0xF0) == 0xE0) {
152 /* start of three byte sequence */
153 machine->s.byte[machine->len++] = c;
154 machine->state = utf8state_expect2;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700155 machine->unicode = c & 0x0f;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000156 } else if((c & 0xF8) == 0xF0) {
157 /* start of four byte sequence */
158 machine->s.byte[machine->len++] = c;
159 machine->state = utf8state_expect3;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700160 machine->unicode = c & 0x07;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000161 } else {
162 /* overlong encoding, reject */
163 machine->state = utf8state_reject;
164 }
165 break;
166 case utf8state_expect3:
167 machine->s.byte[machine->len++] = c;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700168 machine->unicode = (machine->unicode << 6) | (c & 0x3f);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000169 if((c & 0xC0) == 0x80) {
170 /* all good, continue */
171 machine->state = utf8state_expect2;
172 } else {
173 /* missing extra byte, reject */
174 machine->state = utf8state_reject;
175 }
176 break;
177 case utf8state_expect2:
178 machine->s.byte[machine->len++] = c;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700179 machine->unicode = (machine->unicode << 6) | (c & 0x3f);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000180 if((c & 0xC0) == 0x80) {
181 /* all good, continue */
182 machine->state = utf8state_expect1;
183 } else {
184 /* missing extra byte, reject */
185 machine->state = utf8state_reject;
186 }
187 break;
188 case utf8state_expect1:
189 machine->s.byte[machine->len++] = c;
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700190 machine->unicode = (machine->unicode << 6) | (c & 0x3f);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000191 if((c & 0xC0) == 0x80) {
192 /* all good, accept */
193 machine->state = utf8state_accept;
194 } else {
195 /* missing extra byte, reject */
196 machine->state = utf8state_reject;
197 }
198 break;
199 default:
200 machine->state = utf8state_reject;
201 break;
202 }
203
204 return machine->state;
205}
206
Kristian Høgsberg3e125832013-08-13 17:23:54 -0700207static uint32_t
208get_unicode(union utf8_char utf8)
209{
210 struct utf8_state_machine machine;
211 int i;
212
213 init_state_machine(&machine);
214 for (i = 0; i < 4; i++) {
215 utf8_next_char(&machine, utf8.byte[i]);
216 if (machine.state == utf8state_accept ||
217 machine.state == utf8state_reject)
218 break;
219 }
220
221 if (machine.state == utf8state_reject)
222 return 0xfffd;
223
224 return machine.unicode;
225}
226
Peng Wucfcc1112013-08-19 10:59:21 +0800227static bool
228is_wide(union utf8_char utf8)
229{
230 uint32_t unichar = get_unicode(utf8);
231 return wcwidth(unichar) > 1;
232}
233
Callum Lowcay256e72f2011-01-07 19:47:01 +0000234struct char_sub {
235 union utf8_char match;
236 union utf8_char replace;
237};
238/* Set last char_sub match to NULL char */
239typedef struct char_sub *character_set;
240
241struct char_sub CS_US[] = {
242 {{{0, }}, {{0, }}}
243};
244static struct char_sub CS_UK[] = {
David Herrmanna6128d62012-05-29 09:37:02 +0200245 {{{'#', 0, }}, {{0xC2, 0xA3, 0, }}}, /* POUND: £ */
Callum Lowcay256e72f2011-01-07 19:47:01 +0000246 {{{0, }}, {{0, }}}
247};
248static struct char_sub CS_SPECIAL[] = {
David Herrmanna6128d62012-05-29 09:37:02 +0200249 {{{'`', 0, }}, {{0xE2, 0x99, 0xA6, 0}}}, /* diamond: ♦ */
250 {{{'a', 0, }}, {{0xE2, 0x96, 0x92, 0}}}, /* 50% cell: ▒ */
251 {{{'b', 0, }}, {{0xE2, 0x90, 0x89, 0}}}, /* HT: ␉ */
252 {{{'c', 0, }}, {{0xE2, 0x90, 0x8C, 0}}}, /* FF: ␌ */
253 {{{'d', 0, }}, {{0xE2, 0x90, 0x8D, 0}}}, /* CR: ␍ */
254 {{{'e', 0, }}, {{0xE2, 0x90, 0x8A, 0}}}, /* LF: ␊ */
255 {{{'f', 0, }}, {{0xC2, 0xB0, 0, }}}, /* Degree: ° */
256 {{{'g', 0, }}, {{0xC2, 0xB1, 0, }}}, /* Plus/Minus: ± */
257 {{{'h', 0, }}, {{0xE2, 0x90, 0xA4, 0}}}, /* NL: ␤ */
258 {{{'i', 0, }}, {{0xE2, 0x90, 0x8B, 0}}}, /* VT: ␋ */
259 {{{'j', 0, }}, {{0xE2, 0x94, 0x98, 0}}}, /* CN_RB: ┘ */
260 {{{'k', 0, }}, {{0xE2, 0x94, 0x90, 0}}}, /* CN_RT: ┐ */
261 {{{'l', 0, }}, {{0xE2, 0x94, 0x8C, 0}}}, /* CN_LT: ┌ */
262 {{{'m', 0, }}, {{0xE2, 0x94, 0x94, 0}}}, /* CN_LB: └ */
263 {{{'n', 0, }}, {{0xE2, 0x94, 0xBC, 0}}}, /* CROSS: ┼ */
264 {{{'o', 0, }}, {{0xE2, 0x8E, 0xBA, 0}}}, /* Horiz. Scan Line 1: ⎺ */
265 {{{'p', 0, }}, {{0xE2, 0x8E, 0xBB, 0}}}, /* Horiz. Scan Line 3: ⎻ */
266 {{{'q', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* Horiz. Scan Line 5: ─ */
267 {{{'r', 0, }}, {{0xE2, 0x8E, 0xBC, 0}}}, /* Horiz. Scan Line 7: ⎼ */
268 {{{'s', 0, }}, {{0xE2, 0x8E, 0xBD, 0}}}, /* Horiz. Scan Line 9: ⎽ */
269 {{{'t', 0, }}, {{0xE2, 0x94, 0x9C, 0}}}, /* TR: ├ */
270 {{{'u', 0, }}, {{0xE2, 0x94, 0xA4, 0}}}, /* TL: ┤ */
271 {{{'v', 0, }}, {{0xE2, 0x94, 0xB4, 0}}}, /* TU: ┴ */
272 {{{'w', 0, }}, {{0xE2, 0x94, 0xAC, 0}}}, /* TD: ┬ */
273 {{{'x', 0, }}, {{0xE2, 0x94, 0x82, 0}}}, /* V: │ */
274 {{{'y', 0, }}, {{0xE2, 0x89, 0xA4, 0}}}, /* LE: ≤ */
275 {{{'z', 0, }}, {{0xE2, 0x89, 0xA5, 0}}}, /* GE: ≥ */
276 {{{'{', 0, }}, {{0xCF, 0x80, 0, }}}, /* PI: π */
277 {{{'|', 0, }}, {{0xE2, 0x89, 0xA0, 0}}}, /* NEQ: ≠ */
278 {{{'}', 0, }}, {{0xC2, 0xA3, 0, }}}, /* POUND: £ */
279 {{{'~', 0, }}, {{0xE2, 0x8B, 0x85, 0}}}, /* DOT: ⋅ */
Callum Lowcay256e72f2011-01-07 19:47:01 +0000280 {{{0, }}, {{0, }}}
281};
282
283static void
284apply_char_set(character_set cs, union utf8_char *utf8)
285{
286 int i = 0;
287
288 while (cs[i].match.byte[0]) {
289 if ((*utf8).ch == cs[i].match.ch) {
290 *utf8 = cs[i].replace;
291 break;
292 }
293 i++;
294 }
295}
296
Callum Lowcay7e08e902011-01-07 19:47:02 +0000297struct key_map {
298 int sym;
299 int num;
300 char escape;
301 char code;
302};
303/* Set last key_sub sym to NULL */
304typedef struct key_map *keyboard_mode;
305
306static struct key_map KM_NORMAL[] = {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -0400307 { XKB_KEY_Left, 1, '[', 'D' },
308 { XKB_KEY_Right, 1, '[', 'C' },
309 { XKB_KEY_Up, 1, '[', 'A' },
310 { XKB_KEY_Down, 1, '[', 'B' },
311 { XKB_KEY_Home, 1, '[', 'H' },
312 { XKB_KEY_End, 1, '[', 'F' },
313 { 0, 0, 0, 0 }
Callum Lowcay7e08e902011-01-07 19:47:02 +0000314};
315static struct key_map KM_APPLICATION[] = {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -0400316 { XKB_KEY_Left, 1, 'O', 'D' },
317 { XKB_KEY_Right, 1, 'O', 'C' },
318 { XKB_KEY_Up, 1, 'O', 'A' },
319 { XKB_KEY_Down, 1, 'O', 'B' },
320 { XKB_KEY_Home, 1, 'O', 'H' },
321 { XKB_KEY_End, 1, 'O', 'F' },
322 { XKB_KEY_KP_Enter, 1, 'O', 'M' },
323 { XKB_KEY_KP_Multiply, 1, 'O', 'j' },
324 { XKB_KEY_KP_Add, 1, 'O', 'k' },
325 { XKB_KEY_KP_Separator, 1, 'O', 'l' },
326 { XKB_KEY_KP_Subtract, 1, 'O', 'm' },
327 { XKB_KEY_KP_Divide, 1, 'O', 'o' },
328 { 0, 0, 0, 0 }
Callum Lowcay7e08e902011-01-07 19:47:02 +0000329};
330
331static int
332function_key_response(char escape, int num, uint32_t modifiers,
333 char code, char *response)
334{
335 int mod_num = 0;
336 int len;
337
Kristian Høgsberg70163132012-05-08 15:55:39 -0400338 if (modifiers & MOD_SHIFT_MASK) mod_num |= 1;
339 if (modifiers & MOD_ALT_MASK) mod_num |= 2;
340 if (modifiers & MOD_CONTROL_MASK) mod_num |= 4;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000341
342 if (mod_num != 0)
343 len = snprintf(response, MAX_RESPONSE, "\e[%d;%d%c",
344 num, mod_num + 1, code);
345 else if (code != '~')
346 len = snprintf(response, MAX_RESPONSE, "\e%c%c",
347 escape, code);
348 else
349 len = snprintf(response, MAX_RESPONSE, "\e%c%d%c",
350 escape, num, code);
351
352 if (len >= MAX_RESPONSE) return MAX_RESPONSE - 1;
353 else return len;
354}
355
356/* returns the number of bytes written into response,
357 * which must have room for MAX_RESPONSE bytes */
358static int
359apply_key_map(keyboard_mode mode, int sym, uint32_t modifiers, char *response)
360{
361 struct key_map map;
362 int len = 0;
363 int i = 0;
364
365 while (mode[i].sym) {
366 map = mode[i++];
367 if (sym == map.sym) {
368 len = function_key_response(map.escape, map.num,
369 modifiers, map.code,
370 response);
371 break;
372 }
373 }
374
375 return len;
376}
377
Callum Lowcay30eeae52011-01-07 19:46:55 +0000378struct terminal_color { double r, g, b, a; };
379struct attr {
380 unsigned char fg, bg;
381 char a; /* attributes format:
382 * 76543210
Callum Lowcay81179db2011-01-10 12:14:01 +1300383 * cilub */
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500384 char s; /* in selection */
Callum Lowcay30eeae52011-01-07 19:46:55 +0000385};
386struct color_scheme {
387 struct terminal_color palette[16];
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500388 char border;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000389 struct attr default_attr;
390};
391
392static void
393attr_init(struct attr *data_attr, struct attr attr, int n)
394{
395 int i;
396 for (i = 0; i < n; i++) {
397 data_attr[i] = attr;
398 }
399}
400
Callum Lowcay67a201d2011-01-12 19:23:41 +1300401enum escape_state {
402 escape_state_normal = 0,
403 escape_state_escape,
404 escape_state_dcs,
405 escape_state_csi,
406 escape_state_osc,
407 escape_state_inner_escape,
408 escape_state_ignore,
409 escape_state_special
410};
411
412#define ESC_FLAG_WHAT 0x01
413#define ESC_FLAG_GT 0x02
414#define ESC_FLAG_BANG 0x04
415#define ESC_FLAG_CASH 0x08
416#define ESC_FLAG_SQUOTE 0x10
417#define ESC_FLAG_DQUOTE 0x20
418#define ESC_FLAG_SPACE 0x40
419
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400420enum {
421 SELECT_NONE,
422 SELECT_CHAR,
423 SELECT_WORD,
424 SELECT_LINE
425};
426
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500427struct terminal {
428 struct window *window;
Kristian Høgsberg75bc6672012-01-10 09:43:58 -0500429 struct widget *widget;
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -0500430 struct display *display;
Kristian Høgsberga83be202013-10-23 20:47:35 -0700431 char *title;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000432 union utf8_char *data;
Kristian Høgsberg3a696272011-09-14 17:33:48 -0400433 struct task io_task;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000434 char *tab_ruler;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000435 struct attr *data_attr;
436 struct attr curr_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000437 uint32_t mode;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000438 char origin_mode;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000439 char saved_origin_mode;
440 struct attr saved_attr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000441 union utf8_char last_char;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000442 int margin_top, margin_bottom;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000443 character_set cs, g0, g1;
444 character_set saved_cs, saved_g0, saved_g1;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000445 keyboard_mode key_mode;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000446 int data_pitch, attr_pitch; /* The width in bytes of a line */
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700447 int width, height, row, column, max_width;
448 uint32_t buffer_height;
449 uint32_t start, end, saved_start, log_size;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000450 int saved_row, saved_column;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700451 int scrolling;
Scott Moreau7a1b32a2012-05-27 14:25:02 -0600452 int send_cursor_position;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -0500453 int fd, master;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -0500454 uint32_t modifiers;
Callum Lowcayef57a9b2011-01-14 20:46:23 +1300455 char escape[MAX_ESCAPE+1];
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500456 int escape_length;
Callum Lowcay67a201d2011-01-12 19:23:41 +1300457 enum escape_state state;
458 enum escape_state outer_state;
459 int escape_flags;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000460 struct utf8_state_machine state_machine;
Kristian Høgsberg1584c572008-12-08 12:59:37 -0500461 int margin;
Kristian Høgsberg12308a42009-09-28 13:08:50 -0400462 struct color_scheme *color_scheme;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000463 struct terminal_color color_table[256];
Kristian Høgsberg09531622010-06-14 23:22:15 -0400464 cairo_font_extents_t extents;
Peng Wuf291f202013-06-06 15:32:41 +0800465 double average_width;
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -0500466 cairo_scaled_font_t *font_normal, *font_bold;
Kristian Høgsberg88fd4082012-06-21 15:55:03 -0400467 uint32_t hide_cursor_serial;
Kristian Høgsbergb405a802014-02-05 14:44:04 -0800468 int size_in_title;
Kristian Høgsberg58eec362011-01-19 14:27:42 -0500469
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -0400470 struct wl_data_source *selection;
Xiong Zhang49c6aee2013-11-25 18:42:52 +0800471 uint32_t click_time;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400472 int dragging, click_count;
Kristian Høgsberg59826582011-01-20 11:56:57 -0500473 int selection_start_x, selection_start_y;
474 int selection_end_x, selection_end_y;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400475 int selection_start_row, selection_start_col;
476 int selection_end_row, selection_end_col;
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -0400477 struct wl_list link;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500478};
479
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000480/* Create default tab stops, every 8 characters */
481static void
482terminal_init_tabs(struct terminal *terminal)
483{
484 int i = 0;
485
486 while (i < terminal->width) {
487 if (i % 8 == 0)
488 terminal->tab_ruler[i] = 1;
489 else
490 terminal->tab_ruler[i] = 0;
491 i++;
492 }
493}
494
Callum Lowcay30eeae52011-01-07 19:46:55 +0000495static void
496terminal_init(struct terminal *terminal)
497{
498 terminal->curr_attr = terminal->color_scheme->default_attr;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000499 terminal->origin_mode = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000500 terminal->mode = MODE_SHOW_CURSOR |
501 MODE_AUTOREPEAT |
Callum Lowcay7e08e902011-01-07 19:47:02 +0000502 MODE_ALT_SENDS_ESC |
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000503 MODE_AUTOWRAP;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000504
505 terminal->row = 0;
506 terminal->column = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000507
Callum Lowcay256e72f2011-01-07 19:47:01 +0000508 terminal->g0 = CS_US;
509 terminal->g1 = CS_US;
510 terminal->cs = terminal->g0;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000511 terminal->key_mode = KM_NORMAL;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000512
513 terminal->saved_g0 = terminal->g0;
514 terminal->saved_g1 = terminal->g1;
515 terminal->saved_cs = terminal->cs;
516
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000517 terminal->saved_attr = terminal->curr_attr;
518 terminal->saved_origin_mode = terminal->origin_mode;
519 terminal->saved_row = terminal->row;
520 terminal->saved_column = terminal->column;
521
522 if (terminal->tab_ruler != NULL) terminal_init_tabs(terminal);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000523}
524
525static void
526init_color_table(struct terminal *terminal)
527{
528 int c, r;
529 struct terminal_color *color_table = terminal->color_table;
530
531 for (c = 0; c < 256; c ++) {
532 if (c < 16) {
533 color_table[c] = terminal->color_scheme->palette[c];
534 } else if (c < 232) {
535 r = c - 16;
536 color_table[c].b = ((double)(r % 6) / 6.0); r /= 6;
537 color_table[c].g = ((double)(r % 6) / 6.0); r /= 6;
538 color_table[c].r = ((double)(r % 6) / 6.0);
539 color_table[c].a = 1.0;
540 } else {
541 r = (c - 232) * 10 + 8;
542 color_table[c].r = ((double) r) / 256.0;
543 color_table[c].g = color_table[c].r;
544 color_table[c].b = color_table[c].r;
545 color_table[c].a = 1.0;
546 }
547 }
548}
549
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000550static union utf8_char *
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500551terminal_get_row(struct terminal *terminal, int row)
552{
553 int index;
554
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700555 index = (row + terminal->start) & (terminal->buffer_height - 1);
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500556
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700557 return (void *) terminal->data + index * terminal->data_pitch;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500558}
559
Callum Lowcay30eeae52011-01-07 19:46:55 +0000560static struct attr*
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500561terminal_get_attr_row(struct terminal *terminal, int row)
562{
Callum Lowcay30eeae52011-01-07 19:46:55 +0000563 int index;
564
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700565 index = (row + terminal->start) & (terminal->buffer_height - 1);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000566
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700567 return (void *) terminal->data_attr + index * terminal->attr_pitch;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000568}
569
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500570union decoded_attr {
Callum Lowcay9d708b02011-01-12 20:06:17 +1300571 struct attr attr;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500572 uint32_t key;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500573};
574
575static void
576terminal_decode_attr(struct terminal *terminal, int row, int col,
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500577 union decoded_attr *decoded)
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500578{
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500579 struct attr attr;
580 int foreground, background, tmp;
Kristian Høgsberg59826582011-01-20 11:56:57 -0500581
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500582 decoded->attr.s = 0;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400583 if (((row == terminal->selection_start_row &&
584 col >= terminal->selection_start_col) ||
585 row > terminal->selection_start_row) &&
586 ((row == terminal->selection_end_row &&
587 col < terminal->selection_end_col) ||
588 row < terminal->selection_end_row))
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500589 decoded->attr.s = 1;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500590
591 /* get the attributes for this character cell */
592 attr = terminal_get_attr_row(terminal, row)[col];
593 if ((attr.a & ATTRMASK_INVERSE) ||
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500594 decoded->attr.s ||
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500595 ((terminal->mode & MODE_SHOW_CURSOR) &&
Kristian Høgsberg86adef92012-08-13 22:25:53 -0400596 window_has_focus(terminal->window) && terminal->row == row &&
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500597 terminal->column == col)) {
598 foreground = attr.bg;
599 background = attr.fg;
600 if (attr.a & ATTRMASK_BOLD) {
601 if (foreground <= 16) foreground |= 0x08;
602 if (background <= 16) background &= 0x07;
603 }
604 } else {
605 foreground = attr.fg;
606 background = attr.bg;
607 }
608
609 if (terminal->mode & MODE_INVERSE) {
610 tmp = foreground;
611 foreground = background;
612 background = tmp;
613 if (attr.a & ATTRMASK_BOLD) {
614 if (foreground <= 16) foreground |= 0x08;
615 if (background <= 16) background &= 0x07;
616 }
617 }
618
Callum Lowcay9d708b02011-01-12 20:06:17 +1300619 decoded->attr.fg = foreground;
620 decoded->attr.bg = background;
621 decoded->attr.a = attr.a;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000622}
623
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500624
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500625static void
Callum Lowcaybbeac602011-01-07 19:46:58 +0000626terminal_scroll_buffer(struct terminal *terminal, int d)
627{
628 int i;
629
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700630 terminal->start += d;
631 if (d < 0) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000632 d = 0 - d;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700633 for (i = 0; i < d; i++) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000634 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
635 attr_init(terminal_get_attr_row(terminal, i),
636 terminal->curr_attr, terminal->width);
637 }
638 } else {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700639 for (i = terminal->height - d; i < terminal->height; i++) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000640 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
641 attr_init(terminal_get_attr_row(terminal, i),
642 terminal->curr_attr, terminal->width);
643 }
644 }
Kristian Høgsberg18e928d2012-06-27 19:29:41 -0400645
646 terminal->selection_start_row -= d;
647 terminal->selection_end_row -= d;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000648}
649
650static void
651terminal_scroll_window(struct terminal *terminal, int d)
652{
653 int i;
654 int window_height;
655 int from_row, to_row;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000656
657 // scrolling range is inclusive
658 window_height = terminal->margin_bottom - terminal->margin_top + 1;
659 d = d % (window_height + 1);
660 if(d < 0) {
661 d = 0 - d;
662 to_row = terminal->margin_bottom;
663 from_row = terminal->margin_bottom - d;
664
665 for (i = 0; i < (window_height - d); i++) {
666 memcpy(terminal_get_row(terminal, to_row - i),
667 terminal_get_row(terminal, from_row - i),
668 terminal->data_pitch);
669 memcpy(terminal_get_attr_row(terminal, to_row - i),
670 terminal_get_attr_row(terminal, from_row - i),
671 terminal->attr_pitch);
672 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000673 for (i = terminal->margin_top; i < (terminal->margin_top + d); i++) {
674 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000675 attr_init(terminal_get_attr_row(terminal, i),
676 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000677 }
678 } else {
679 to_row = terminal->margin_top;
680 from_row = terminal->margin_top + d;
681
682 for (i = 0; i < (window_height - d); i++) {
683 memcpy(terminal_get_row(terminal, to_row + i),
684 terminal_get_row(terminal, from_row + i),
685 terminal->data_pitch);
686 memcpy(terminal_get_attr_row(terminal, to_row + i),
687 terminal_get_attr_row(terminal, from_row + i),
688 terminal->attr_pitch);
689 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000690 for (i = terminal->margin_bottom - d + 1; i <= terminal->margin_bottom; i++) {
691 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000692 attr_init(terminal_get_attr_row(terminal, i),
693 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000694 }
695 }
696}
697
698static void
699terminal_scroll(struct terminal *terminal, int d)
700{
701 if(terminal->margin_top == 0 && terminal->margin_bottom == terminal->height - 1)
702 terminal_scroll_buffer(terminal, d);
703 else
704 terminal_scroll_window(terminal, d);
705}
706
707static void
Callum Lowcay69e96582011-01-07 19:47:00 +0000708terminal_shift_line(struct terminal *terminal, int d)
709{
710 union utf8_char *row;
Kristian Høgsberg00439612011-01-25 15:16:01 -0500711 struct attr *attr_row;
Callum Lowcay69e96582011-01-07 19:47:00 +0000712
713 row = terminal_get_row(terminal, terminal->row);
714 attr_row = terminal_get_attr_row(terminal, terminal->row);
715
716 if ((terminal->width + d) <= terminal->column)
717 d = terminal->column + 1 - terminal->width;
718 if ((terminal->column + d) >= terminal->width)
719 d = terminal->width - terminal->column - 1;
720
721 if (d < 0) {
722 d = 0 - d;
723 memmove(&row[terminal->column],
724 &row[terminal->column + d],
725 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
Callum Lowcay69e96582011-01-07 19:47:00 +0000726 memmove(&attr_row[terminal->column], &attr_row[terminal->column + d],
727 (terminal->width - terminal->column - d) * sizeof(struct attr));
728 memset(&row[terminal->width - d], 0, d * sizeof(union utf8_char));
729 attr_init(&attr_row[terminal->width - d], terminal->curr_attr, d);
730 } else {
731 memmove(&row[terminal->column + d], &row[terminal->column],
732 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
733 memmove(&attr_row[terminal->column + d], &attr_row[terminal->column],
734 (terminal->width - terminal->column - d) * sizeof(struct attr));
735 memset(&row[terminal->column], 0, d * sizeof(union utf8_char));
736 attr_init(&attr_row[terminal->column], terminal->curr_attr, d);
737 }
738}
739
740static void
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700741terminal_resize_cells(struct terminal *terminal,
742 int width, int height)
Kristian Høgsberg22106762008-12-08 13:50:07 -0500743{
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000744 union utf8_char *data;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000745 struct attr *data_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000746 char *tab_ruler;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000747 int data_pitch, attr_pitch;
Kristian Høgsberg00439612011-01-25 15:16:01 -0500748 int i, l, total_rows;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700749 uint32_t d, uheight = height;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500750 struct rectangle allocation;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000751 struct winsize ws;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500752
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700753 if (uheight > terminal->buffer_height)
754 height = terminal->buffer_height;
755
Kristian Høgsberg22106762008-12-08 13:50:07 -0500756 if (terminal->width == width && terminal->height == height)
757 return;
758
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700759 if (terminal->data && width <= terminal->max_width) {
760 d = 0;
761 if (height < terminal->height && height <= terminal->row)
762 d = terminal->height - height;
763 else if (height > terminal->height &&
764 terminal->height - 1 == terminal->row) {
765 d = terminal->height - height;
766 if (terminal->log_size < uheight)
767 d = -terminal->start;
768 }
Kristian Høgsberg22106762008-12-08 13:50:07 -0500769
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700770 terminal->start += d;
771 terminal->row -= d;
772 } else {
773 terminal->max_width = width;
774 data_pitch = width * sizeof(union utf8_char);
Bryce W. Harrington66cd2c12014-04-28 18:44:08 +0000775 data = xzalloc(data_pitch * terminal->buffer_height);
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700776 attr_pitch = width * sizeof(struct attr);
Bryce W. Harrington66cd2c12014-04-28 18:44:08 +0000777 data_attr = xmalloc(attr_pitch * terminal->buffer_height);
778 tab_ruler = xzalloc(width);
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700779 attr_init(data_attr, terminal->curr_attr,
780 width * terminal->buffer_height);
781
782 if (terminal->data && terminal->data_attr) {
783 if (width > terminal->width)
784 l = terminal->width;
785 else
786 l = width;
787
788 if (terminal->height > height) {
789 total_rows = height;
790 i = 1 + terminal->row - height;
791 if (i > 0) {
792 terminal->start += i;
793 terminal->row = terminal->row - i;
794 }
795 } else {
796 total_rows = terminal->height;
José Bollo4a4704a2013-09-13 11:28:51 +0200797 }
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700798
799 for (i = 0; i < total_rows; i++) {
800 memcpy(&data[width * i],
801 terminal_get_row(terminal, i),
802 l * sizeof(union utf8_char));
803 memcpy(&data_attr[width * i],
804 terminal_get_attr_row(terminal, i),
805 l * sizeof(struct attr));
806 }
807
808 free(terminal->data);
809 free(terminal->data_attr);
810 free(terminal->tab_ruler);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500811 }
812
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700813 terminal->data_pitch = data_pitch;
814 terminal->attr_pitch = attr_pitch;
815 terminal->data = data;
816 terminal->data_attr = data_attr;
817 terminal->tab_ruler = tab_ruler;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700818 terminal->start = 0;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500819 }
820
Callum Lowcay86653ed2011-01-07 19:47:03 +0000821 terminal->margin_bottom =
822 height - (terminal->height - terminal->margin_bottom);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500823 terminal->width = width;
824 terminal->height = height;
Kristian Høgsbergdcfff552013-11-22 22:43:20 -0800825 terminal_init_tabs(terminal);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500826
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000827 /* Update the window size */
828 ws.ws_row = terminal->height;
829 ws.ws_col = terminal->width;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500830 widget_get_allocation(terminal->widget, &allocation);
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500831 ws.ws_xpixel = allocation.width;
832 ws.ws_ypixel = allocation.height;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000833 ioctl(terminal->master, TIOCSWINSZ, &ws);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500834}
835
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500836static void
Jasper St. Pierrede680992014-04-10 17:23:49 -0700837update_title(struct terminal *terminal)
838{
839 if (window_is_resizing(terminal->window)) {
840 char *p;
841 if (asprintf(&p, "%s — [%dx%d]", terminal->title, terminal->width, terminal->height) > 0) {
842 window_set_title(terminal->window, p);
843 free(p);
844 }
845 } else {
846 window_set_title(terminal->window, terminal->title);
847 }
848}
849
850static void
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500851resize_handler(struct widget *widget,
852 int32_t width, int32_t height, void *data)
853{
854 struct terminal *terminal = data;
855 int32_t columns, rows, m;
Jasper St. Pierrede680992014-04-10 17:23:49 -0700856
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500857 m = 2 * terminal->margin;
Peng Wuf291f202013-06-06 15:32:41 +0800858 columns = (width - m) / (int32_t) terminal->average_width;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500859 rows = (height - m) / (int32_t) terminal->extents.height;
860
Kristian Høgsbergb36f7ef2012-10-10 11:41:21 -0400861 if (!window_is_fullscreen(terminal->window) &&
862 !window_is_maximized(terminal->window)) {
Peng Wuf291f202013-06-06 15:32:41 +0800863 width = columns * terminal->average_width + m;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500864 height = rows * terminal->extents.height + m;
865 widget_set_size(terminal->widget, width, height);
866 }
867
868 terminal_resize_cells(terminal, columns, rows);
Jasper St. Pierrede680992014-04-10 17:23:49 -0700869 update_title(terminal);
870}
871
872static void
873state_changed_handler(struct window *window, void *data)
874{
875 struct terminal *terminal = data;
876 update_title(terminal);
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500877}
878
879static void
880terminal_resize(struct terminal *terminal, int columns, int rows)
881{
882 int32_t width, height, m;
883
Kristian Høgsbergb36f7ef2012-10-10 11:41:21 -0400884 if (window_is_fullscreen(terminal->window) ||
885 window_is_maximized(terminal->window))
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500886 return;
887
888 m = 2 * terminal->margin;
Peng Wuf291f202013-06-06 15:32:41 +0800889 width = columns * terminal->average_width + m;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500890 height = rows * terminal->extents.height + m;
Kristian Høgsberga1627922012-06-20 17:30:03 -0400891
Jason Ekstrandee7fefc2013-10-13 19:08:38 -0500892 window_frame_set_child_size(terminal->widget, width, height);
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500893}
894
Callum Lowcay30eeae52011-01-07 19:46:55 +0000895struct color_scheme DEFAULT_COLORS = {
896 {
897 {0, 0, 0, 1}, /* black */
898 {0.66, 0, 0, 1}, /* red */
899 {0 , 0.66, 0, 1}, /* green */
900 {0.66, 0.33, 0, 1}, /* orange (nicer than muddy yellow) */
901 {0 , 0 , 0.66, 1}, /* blue */
902 {0.66, 0 , 0.66, 1}, /* magenta */
903 {0, 0.66, 0.66, 1}, /* cyan */
904 {0.66, 0.66, 0.66, 1}, /* light grey */
905 {0.22, 0.33, 0.33, 1}, /* dark grey */
906 {1, 0.33, 0.33, 1}, /* high red */
907 {0.33, 1, 0.33, 1}, /* high green */
908 {1, 1, 0.33, 1}, /* high yellow */
909 {0.33, 0.33, 1, 1}, /* high blue */
910 {1, 0.33, 1, 1}, /* high magenta */
911 {0.33, 1, 1, 1}, /* high cyan */
912 {1, 1, 1, 1} /* white */
913 },
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500914 0, /* black border */
Callum Lowcay30eeae52011-01-07 19:46:55 +0000915 {7, 0, 0, } /* bg:black (0), fg:light gray (7) */
916};
Kristian Høgsberg12308a42009-09-28 13:08:50 -0400917
Kristian Høgsberg22106762008-12-08 13:50:07 -0500918static void
Kristian Høgsbergf106fd52011-01-11 10:11:39 -0500919terminal_set_color(struct terminal *terminal, cairo_t *cr, int index)
920{
921 cairo_set_source_rgba(cr,
922 terminal->color_table[index].r,
923 terminal->color_table[index].g,
924 terminal->color_table[index].b,
925 terminal->color_table[index].a);
926}
927
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500928static void
929terminal_send_selection(struct terminal *terminal, int fd)
930{
931 int row, col;
932 union utf8_char *p_row;
933 union decoded_attr attr;
934 FILE *fp;
935 int len;
936
937 fp = fdopen(fd, "w");
Brian Lovin1bf14812013-08-08 16:12:55 -0700938 if (fp == NULL){
939 close(fd);
940 return;
941 }
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500942 for (row = 0; row < terminal->height; row++) {
943 p_row = terminal_get_row(terminal, row);
944 for (col = 0; col < terminal->width; col++) {
Peng Wucfcc1112013-08-19 10:59:21 +0800945 if (p_row[col].ch == 0x200B) /* space glyph */
946 continue;
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500947 /* get the attributes for this character cell */
948 terminal_decode_attr(terminal, row, col, &attr);
949 if (!attr.attr.s)
950 continue;
951 len = strnlen((char *) p_row[col].byte, 4);
Kristian Høgsberg0dee6472012-07-01 21:25:41 -0400952 if (len > 0)
953 fwrite(p_row[col].byte, 1, len, fp);
954 if (len == 0 || col == terminal->width - 1) {
955 fwrite("\n", 1, 1, fp);
956 break;
957 }
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500958 }
959 }
960 fclose(fp);
961}
962
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500963struct glyph_run {
964 struct terminal *terminal;
965 cairo_t *cr;
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -0400966 unsigned int count;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500967 union decoded_attr attr;
968 cairo_glyph_t glyphs[256], *g;
969};
970
971static void
972glyph_run_init(struct glyph_run *run, struct terminal *terminal, cairo_t *cr)
973{
974 run->terminal = terminal;
975 run->cr = cr;
976 run->g = run->glyphs;
977 run->count = 0;
978 run->attr.key = 0;
979}
980
981static void
982glyph_run_flush(struct glyph_run *run, union decoded_attr attr)
983{
984 cairo_scaled_font_t *font;
985
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500986 if (run->count > ARRAY_LENGTH(run->glyphs) - 10 ||
987 (attr.key != run->attr.key)) {
Callum Lowcay9d708b02011-01-12 20:06:17 +1300988 if (run->attr.attr.a & (ATTRMASK_BOLD | ATTRMASK_BLINK))
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500989 font = run->terminal->font_bold;
990 else
991 font = run->terminal->font_normal;
992 cairo_set_scaled_font(run->cr, font);
993 terminal_set_color(run->terminal, run->cr,
Callum Lowcay9d708b02011-01-12 20:06:17 +1300994 run->attr.attr.fg);
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500995
Callum Lowcay9d708b02011-01-12 20:06:17 +1300996 if (!(run->attr.attr.a & ATTRMASK_CONCEALED))
997 cairo_show_glyphs (run->cr, run->glyphs, run->count);
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500998 run->g = run->glyphs;
999 run->count = 0;
1000 }
Callum Lowcay9d708b02011-01-12 20:06:17 +13001001 run->attr = attr;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001002}
1003
1004static void
1005glyph_run_add(struct glyph_run *run, int x, int y, union utf8_char *c)
1006{
1007 int num_glyphs;
1008 cairo_scaled_font_t *font;
1009
1010 num_glyphs = ARRAY_LENGTH(run->glyphs) - run->count;
1011
Callum Lowcay9d708b02011-01-12 20:06:17 +13001012 if (run->attr.attr.a & (ATTRMASK_BOLD | ATTRMASK_BLINK))
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001013 font = run->terminal->font_bold;
1014 else
1015 font = run->terminal->font_normal;
1016
1017 cairo_move_to(run->cr, x, y);
1018 cairo_scaled_font_text_to_glyphs (font, x, y,
1019 (char *) c->byte, 4,
1020 &run->g, &num_glyphs,
1021 NULL, NULL, NULL);
1022 run->g += num_glyphs;
1023 run->count += num_glyphs;
1024}
1025
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001026
Kristian Høgsbergf106fd52011-01-11 10:11:39 -05001027static void
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001028redraw_handler(struct widget *widget, void *data)
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001029{
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001030 struct terminal *terminal = data;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -05001031 struct rectangle allocation;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001032 cairo_t *cr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001033 int top_margin, side_margin;
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001034 int row, col, cursor_x, cursor_y;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001035 union utf8_char *p_row;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001036 union decoded_attr attr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001037 int text_x, text_y;
Kristian Høgsberg2aac3022009-12-21 10:04:53 -05001038 cairo_surface_t *surface;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001039 double d;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001040 struct glyph_run run;
Kristian Høgsberg59826582011-01-20 11:56:57 -05001041 cairo_font_extents_t extents;
Peng Wuf291f202013-06-06 15:32:41 +08001042 double average_width;
Peng Wucfcc1112013-08-19 10:59:21 +08001043 double unichar_width;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001044
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001045 surface = window_get_surface(terminal->window);
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001046 widget_get_allocation(terminal->widget, &allocation);
Alexander Larssonde79dd02013-05-22 14:41:34 +02001047 cr = widget_cairo_create(terminal->widget);
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001048 cairo_rectangle(cr, allocation.x, allocation.y,
1049 allocation.width, allocation.height);
1050 cairo_clip(cr);
1051 cairo_push_group(cr);
1052
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001053 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
Kristian Høgsberg71eca892011-01-11 10:13:00 -05001054 terminal_set_color(terminal, cr, terminal->color_scheme->border);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001055 cairo_paint(cr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001056
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05001057 cairo_set_scaled_font(cr, terminal->font_normal);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001058
Kristian Høgsberg59826582011-01-20 11:56:57 -05001059 extents = terminal->extents;
Peng Wuf291f202013-06-06 15:32:41 +08001060 average_width = terminal->average_width;
1061 side_margin = (allocation.width - terminal->width * average_width) / 2;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -05001062 top_margin = (allocation.height - terminal->height * extents.height) / 2;
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001063
Callum Lowcay30eeae52011-01-07 19:46:55 +00001064 cairo_set_line_width(cr, 1.0);
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001065 cairo_translate(cr, allocation.x + side_margin,
1066 allocation.y + top_margin);
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001067 /* paint the background */
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001068 for (row = 0; row < terminal->height; row++) {
Peng Wucfcc1112013-08-19 10:59:21 +08001069 p_row = terminal_get_row(terminal, row);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001070 for (col = 0; col < terminal->width; col++) {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001071 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -05001072 terminal_decode_attr(terminal, row, col, &attr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001073
Callum Lowcay9d708b02011-01-12 20:06:17 +13001074 if (attr.attr.bg == terminal->color_scheme->border)
Kristian Høgsbergfb266a32011-01-11 10:15:21 -05001075 continue;
1076
Peng Wucfcc1112013-08-19 10:59:21 +08001077 if (is_wide(p_row[col]))
1078 unichar_width = 2 * average_width;
1079 else
1080 unichar_width = average_width;
1081
Callum Lowcay9d708b02011-01-12 20:06:17 +13001082 terminal_set_color(terminal, cr, attr.attr.bg);
Peng Wuf291f202013-06-06 15:32:41 +08001083 cairo_move_to(cr, col * average_width,
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001084 row * extents.height);
Peng Wucfcc1112013-08-19 10:59:21 +08001085 cairo_rel_line_to(cr, unichar_width, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001086 cairo_rel_line_to(cr, 0, extents.height);
Peng Wucfcc1112013-08-19 10:59:21 +08001087 cairo_rel_line_to(cr, -unichar_width, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001088 cairo_close_path(cr);
1089 cairo_fill(cr);
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001090 }
1091 }
Callum Lowcay30eeae52011-01-07 19:46:55 +00001092
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001093 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
1094
1095 /* paint the foreground */
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001096 glyph_run_init(&run, terminal, cr);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001097 for (row = 0; row < terminal->height; row++) {
1098 p_row = terminal_get_row(terminal, row);
1099 for (col = 0; col < terminal->width; col++) {
1100 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -05001101 terminal_decode_attr(terminal, row, col, &attr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001102
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001103 glyph_run_flush(&run, attr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001104
Peng Wuf291f202013-06-06 15:32:41 +08001105 text_x = col * average_width;
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001106 text_y = extents.ascent + row * extents.height;
Callum Lowcay9d708b02011-01-12 20:06:17 +13001107 if (attr.attr.a & ATTRMASK_UNDERLINE) {
1108 terminal_set_color(terminal, cr, attr.attr.fg);
Callum Lowcay86653ed2011-01-07 19:47:03 +00001109 cairo_move_to(cr, text_x, (double)text_y + 1.5);
Peng Wuf291f202013-06-06 15:32:41 +08001110 cairo_line_to(cr, text_x + average_width, (double) text_y + 1.5);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001111 cairo_stroke(cr);
1112 }
Kristian Høgsberg4f506702010-12-25 16:14:23 -05001113
Daiki Ueno56d8a7a2014-04-08 18:46:18 +09001114 /* skip space glyph (RLE) we use as a placeholder of
1115 the right half of a double-width character,
1116 because RLE is not available in every font. */
1117 if (p_row[col].ch == 0x200B)
1118 continue;
1119
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001120 glyph_run_add(&run, text_x, text_y, &p_row[col]);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001121 }
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001122 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -05001123
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001124 attr.key = ~0;
1125 glyph_run_flush(&run, attr);
1126
Kristian Høgsberg86adef92012-08-13 22:25:53 -04001127 if ((terminal->mode & MODE_SHOW_CURSOR) &&
1128 !window_has_focus(terminal->window)) {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001129 d = 0.5;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001130
Callum Lowcay30eeae52011-01-07 19:46:55 +00001131 cairo_set_line_width(cr, 1);
Peng Wuf291f202013-06-06 15:32:41 +08001132 cairo_move_to(cr, terminal->column * average_width + d,
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001133 terminal->row * extents.height + d);
Peng Wuf291f202013-06-06 15:32:41 +08001134 cairo_rel_line_to(cr, average_width - 2 * d, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001135 cairo_rel_line_to(cr, 0, extents.height - 2 * d);
Peng Wuf291f202013-06-06 15:32:41 +08001136 cairo_rel_line_to(cr, -average_width + 2 * d, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001137 cairo_close_path(cr);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001138
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001139 cairo_stroke(cr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001140 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -05001141
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001142 cairo_pop_group_to_source(cr);
1143 cairo_paint(cr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001144 cairo_destroy(cr);
Kristian Høgsberg2aac3022009-12-21 10:04:53 -05001145 cairo_surface_destroy(surface);
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001146
1147 if (terminal->send_cursor_position) {
1148 cursor_x = side_margin + allocation.x +
Peng Wuf291f202013-06-06 15:32:41 +08001149 terminal->column * average_width;
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001150 cursor_y = top_margin + allocation.y +
1151 terminal->row * extents.height;
1152 window_set_text_cursor_position(terminal->window,
1153 cursor_x, cursor_y);
1154 terminal->send_cursor_position = 0;
1155 }
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001156}
1157
1158static void
Kristian Høgsberg26130862011-08-24 11:30:21 -04001159terminal_write(struct terminal *terminal, const char *data, size_t length)
1160{
1161 if (write(terminal->master, data, length) < 0)
1162 abort();
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001163 terminal->send_cursor_position = 1;
Kristian Høgsberg26130862011-08-24 11:30:21 -04001164}
1165
1166static void
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001167terminal_data(struct terminal *terminal, const char *data, size_t length);
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05001168
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001169static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001170handle_char(struct terminal *terminal, union utf8_char utf8);
1171
1172static void
Callum Lowcay30eeae52011-01-07 19:46:55 +00001173handle_sgr(struct terminal *terminal, int code);
1174
1175static void
Callum Lowcaybbeac602011-01-07 19:46:58 +00001176handle_term_parameter(struct terminal *terminal, int code, int sr)
1177{
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001178 int i;
1179
Callum Lowcay67a201d2011-01-12 19:23:41 +13001180 if (terminal->escape_flags & ESC_FLAG_WHAT) {
Callum Lowcaybbeac602011-01-07 19:46:58 +00001181 switch(code) {
Callum Lowcay7e08e902011-01-07 19:47:02 +00001182 case 1: /* DECCKM */
1183 if (sr) terminal->key_mode = KM_APPLICATION;
1184 else terminal->key_mode = KM_NORMAL;
1185 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001186 case 2: /* DECANM */
1187 /* No VT52 support yet */
1188 terminal->g0 = CS_US;
1189 terminal->g1 = CS_US;
1190 terminal->cs = terminal->g0;
1191 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001192 case 3: /* DECCOLM */
1193 if (sr)
1194 terminal_resize(terminal, 132, 24);
1195 else
1196 terminal_resize(terminal, 80, 24);
1197
1198 /* set columns, but also home cursor and clear screen */
1199 terminal->row = 0; terminal->column = 0;
1200 for (i = 0; i < terminal->height; i++) {
1201 memset(terminal_get_row(terminal, i),
1202 0, terminal->data_pitch);
1203 attr_init(terminal_get_attr_row(terminal, i),
1204 terminal->curr_attr, terminal->width);
1205 }
1206 break;
1207 case 5: /* DECSCNM */
1208 if (sr) terminal->mode |= MODE_INVERSE;
1209 else terminal->mode &= ~MODE_INVERSE;
1210 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001211 case 6: /* DECOM */
1212 terminal->origin_mode = sr;
1213 if (terminal->origin_mode)
1214 terminal->row = terminal->margin_top;
1215 else
1216 terminal->row = 0;
1217 terminal->column = 0;
1218 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001219 case 7: /* DECAWM */
1220 if (sr) terminal->mode |= MODE_AUTOWRAP;
1221 else terminal->mode &= ~MODE_AUTOWRAP;
1222 break;
1223 case 8: /* DECARM */
1224 if (sr) terminal->mode |= MODE_AUTOREPEAT;
1225 else terminal->mode &= ~MODE_AUTOREPEAT;
1226 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001227 case 12: /* Very visible cursor (CVVIS) */
1228 /* FIXME: What do we do here. */
1229 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001230 case 25:
1231 if (sr) terminal->mode |= MODE_SHOW_CURSOR;
1232 else terminal->mode &= ~MODE_SHOW_CURSOR;
1233 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001234 case 1034: /* smm/rmm, meta mode on/off */
1235 /* ignore */
1236 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001237 case 1037: /* deleteSendsDel */
1238 if (sr) terminal->mode |= MODE_DELETE_SENDS_DEL;
1239 else terminal->mode &= ~MODE_DELETE_SENDS_DEL;
1240 break;
1241 case 1039: /* altSendsEscape */
1242 if (sr) terminal->mode |= MODE_ALT_SENDS_ESC;
1243 else terminal->mode &= ~MODE_ALT_SENDS_ESC;
1244 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001245 case 1049: /* rmcup/smcup, alternate screen */
1246 /* Ignore. Should be possible to implement,
1247 * but it's kind of annoying. */
1248 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001249 default:
1250 fprintf(stderr, "Unknown parameter: ?%d\n", code);
1251 break;
1252 }
1253 } else {
1254 switch(code) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001255 case 4: /* IRM */
1256 if (sr) terminal->mode |= MODE_IRM;
1257 else terminal->mode &= ~MODE_IRM;
1258 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001259 case 20: /* LNM */
1260 if (sr) terminal->mode |= MODE_LF_NEWLINE;
1261 else terminal->mode &= ~MODE_LF_NEWLINE;
1262 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001263 default:
1264 fprintf(stderr, "Unknown parameter: %d\n", code);
1265 break;
1266 }
1267 }
1268}
1269
1270static void
Callum Lowcay67a201d2011-01-12 19:23:41 +13001271handle_dcs(struct terminal *terminal)
1272{
1273}
1274
1275static void
1276handle_osc(struct terminal *terminal)
1277{
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001278 char *p;
1279 int code;
1280
1281 terminal->escape[terminal->escape_length++] = '\0';
1282 p = &terminal->escape[2];
1283 code = strtol(p, &p, 10);
1284 if (*p == ';') p++;
1285
1286 switch (code) {
1287 case 0: /* Icon name and window title */
1288 case 1: /* Icon label */
1289 case 2: /* Window title*/
Kristian Høgsberga83be202013-10-23 20:47:35 -07001290 free(terminal->title);
1291 terminal->title = strdup(p);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001292 window_set_title(terminal->window, p);
1293 break;
Kristian Høgsberg8a205002013-09-11 11:52:56 -07001294 case 7: /* shell cwd as uri */
1295 break;
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001296 default:
Kristian Høgsberg8a205002013-09-11 11:52:56 -07001297 fprintf(stderr, "Unknown OSC escape code %d, text %s\n",
1298 code, p);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001299 break;
1300 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13001301}
1302
1303static void
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001304handle_escape(struct terminal *terminal)
1305{
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001306 union utf8_char *row;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001307 struct attr *attr_row;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001308 char *p;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001309 int i, count, x, y, top, bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001310 int args[10], set[10] = { 0, };
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001311 char response[MAX_RESPONSE] = {0, };
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001312 struct rectangle allocation;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001313
1314 terminal->escape[terminal->escape_length++] = '\0';
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001315 i = 0;
1316 p = &terminal->escape[2];
1317 while ((isdigit(*p) || *p == ';') && i < 10) {
1318 if (*p == ';') {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001319 if (!set[i]) {
1320 args[i] = 0;
1321 set[i] = 1;
1322 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001323 p++;
1324 i++;
1325 } else {
1326 args[i] = strtol(p, &p, 10);
1327 set[i] = 1;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001328 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001329 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001330
1331 switch (*p) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001332 case '@': /* ICH */
1333 count = set[0] ? args[0] : 1;
1334 if (count == 0) count = 1;
1335 terminal_shift_line(terminal, count);
1336 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001337 case 'A': /* CUU */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001338 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001339 if (count == 0) count = 1;
1340 if (terminal->row - count >= terminal->margin_top)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001341 terminal->row -= count;
1342 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001343 terminal->row = terminal->margin_top;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001344 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001345 case 'B': /* CUD */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001346 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001347 if (count == 0) count = 1;
1348 if (terminal->row + count <= terminal->margin_bottom)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001349 terminal->row += count;
1350 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001351 terminal->row = terminal->margin_bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001352 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001353 case 'C': /* CUF */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001354 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001355 if (count == 0) count = 1;
1356 if ((terminal->column + count) < terminal->width)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001357 terminal->column += count;
1358 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001359 terminal->column = terminal->width - 1;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001360 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001361 case 'D': /* CUB */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001362 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001363 if (count == 0) count = 1;
1364 if ((terminal->column - count) >= 0)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001365 terminal->column -= count;
1366 else
1367 terminal->column = 0;
1368 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001369 case 'E': /* CNL */
1370 count = set[0] ? args[0] : 1;
1371 if (terminal->row + count <= terminal->margin_bottom)
1372 terminal->row += count;
1373 else
1374 terminal->row = terminal->margin_bottom;
1375 terminal->column = 0;
1376 break;
1377 case 'F': /* CPL */
1378 count = set[0] ? args[0] : 1;
1379 if (terminal->row - count >= terminal->margin_top)
1380 terminal->row -= count;
1381 else
1382 terminal->row = terminal->margin_top;
1383 terminal->column = 0;
1384 break;
1385 case 'G': /* CHA */
1386 y = set[0] ? args[0] : 1;
1387 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1388
1389 terminal->column = y - 1;
1390 break;
1391 case 'f': /* HVP */
1392 case 'H': /* CUP */
1393 x = (set[1] ? args[1] : 1) - 1;
1394 x = x < 0 ? 0 :
1395 (x >= terminal->width ? terminal->width - 1 : x);
1396
1397 y = (set[0] ? args[0] : 1) - 1;
1398 if (terminal->origin_mode) {
1399 y += terminal->margin_top;
1400 y = y < terminal->margin_top ? terminal->margin_top :
1401 (y > terminal->margin_bottom ? terminal->margin_bottom : y);
1402 } else {
1403 y = y < 0 ? 0 :
1404 (y >= terminal->height ? terminal->height - 1 : y);
1405 }
1406
1407 terminal->row = y;
1408 terminal->column = x;
1409 break;
1410 case 'I': /* CHT */
1411 count = set[0] ? args[0] : 1;
1412 if (count == 0) count = 1;
1413 while (count > 0 && terminal->column < terminal->width) {
1414 if (terminal->tab_ruler[terminal->column]) count--;
1415 terminal->column++;
1416 }
1417 terminal->column--;
1418 break;
1419 case 'J': /* ED */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001420 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001421 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001422 if (!set[0] || args[0] == 0 || args[0] > 2) {
1423 memset(&row[terminal->column],
1424 0, (terminal->width - terminal->column) * sizeof(union utf8_char));
1425 attr_init(&attr_row[terminal->column],
1426 terminal->curr_attr, terminal->width - terminal->column);
1427 for (i = terminal->row + 1; i < terminal->height; i++) {
1428 memset(terminal_get_row(terminal, i),
1429 0, terminal->data_pitch);
1430 attr_init(terminal_get_attr_row(terminal, i),
1431 terminal->curr_attr, terminal->width);
1432 }
1433 } else if (args[0] == 1) {
1434 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1435 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1436 for (i = 0; i < terminal->row; i++) {
1437 memset(terminal_get_row(terminal, i),
1438 0, terminal->data_pitch);
1439 attr_init(terminal_get_attr_row(terminal, i),
1440 terminal->curr_attr, terminal->width);
1441 }
1442 } else if (args[0] == 2) {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07001443 /* Clear screen by scrolling contents out */
1444 terminal_scroll_buffer(terminal,
1445 terminal->end - terminal->start);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001446 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001447 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001448 case 'K': /* EL */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001449 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001450 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001451 if (!set[0] || args[0] == 0 || args[0] > 2) {
1452 memset(&row[terminal->column], 0,
1453 (terminal->width - terminal->column) * sizeof(union utf8_char));
1454 attr_init(&attr_row[terminal->column], terminal->curr_attr,
1455 terminal->width - terminal->column);
1456 } else if (args[0] == 1) {
1457 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1458 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1459 } else if (args[0] == 2) {
1460 memset(row, 0, terminal->data_pitch);
1461 attr_init(attr_row, terminal->curr_attr, terminal->width);
1462 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001463 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001464 case 'L': /* IL */
1465 count = set[0] ? args[0] : 1;
1466 if (count == 0) count = 1;
1467 if (terminal->row >= terminal->margin_top &&
1468 terminal->row < terminal->margin_bottom)
1469 {
1470 top = terminal->margin_top;
1471 terminal->margin_top = terminal->row;
1472 terminal_scroll(terminal, 0 - count);
1473 terminal->margin_top = top;
1474 } else if (terminal->row == terminal->margin_bottom) {
1475 memset(terminal_get_row(terminal, terminal->row),
1476 0, terminal->data_pitch);
1477 attr_init(terminal_get_attr_row(terminal, terminal->row),
1478 terminal->curr_attr, terminal->width);
1479 }
1480 break;
1481 case 'M': /* DL */
1482 count = set[0] ? args[0] : 1;
1483 if (count == 0) count = 1;
1484 if (terminal->row >= terminal->margin_top &&
1485 terminal->row < terminal->margin_bottom)
1486 {
1487 top = terminal->margin_top;
1488 terminal->margin_top = terminal->row;
1489 terminal_scroll(terminal, count);
1490 terminal->margin_top = top;
1491 } else if (terminal->row == terminal->margin_bottom) {
1492 memset(terminal_get_row(terminal, terminal->row),
1493 0, terminal->data_pitch);
1494 }
1495 break;
1496 case 'P': /* DCH */
1497 count = set[0] ? args[0] : 1;
1498 if (count == 0) count = 1;
1499 terminal_shift_line(terminal, 0 - count);
1500 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001501 case 'S': /* SU */
1502 terminal_scroll(terminal, set[0] ? args[0] : 1);
1503 break;
1504 case 'T': /* SD */
1505 terminal_scroll(terminal, 0 - (set[0] ? args[0] : 1));
1506 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001507 case 'X': /* ECH */
1508 count = set[0] ? args[0] : 1;
1509 if (count == 0) count = 1;
1510 if ((terminal->column + count) > terminal->width)
1511 count = terminal->width - terminal->column;
1512 row = terminal_get_row(terminal, terminal->row);
1513 attr_row = terminal_get_attr_row(terminal, terminal->row);
1514 memset(&row[terminal->column], 0, count * sizeof(union utf8_char));
1515 attr_init(&attr_row[terminal->column], terminal->curr_attr, count);
1516 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001517 case 'Z': /* CBT */
1518 count = set[0] ? args[0] : 1;
1519 if (count == 0) count = 1;
1520 while (count > 0 && terminal->column >= 0) {
1521 if (terminal->tab_ruler[terminal->column]) count--;
1522 terminal->column--;
1523 }
1524 terminal->column++;
1525 break;
1526 case '`': /* HPA */
1527 y = set[0] ? args[0] : 1;
1528 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1529
1530 terminal->column = y - 1;
1531 break;
1532 case 'b': /* REP */
1533 count = set[0] ? args[0] : 1;
1534 if (count == 0) count = 1;
1535 if (terminal->last_char.byte[0])
1536 for (i = 0; i < count; i++)
1537 handle_char(terminal, terminal->last_char);
1538 terminal->last_char.byte[0] = 0;
1539 break;
1540 case 'c': /* Primary DA */
Kristian Høgsberg26130862011-08-24 11:30:21 -04001541 terminal_write(terminal, "\e[?6c", 5);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001542 break;
1543 case 'd': /* VPA */
1544 x = set[0] ? args[0] : 1;
1545 x = x <= 0 ? 1 : x > terminal->height ? terminal->height : x;
1546
1547 terminal->row = x - 1;
1548 break;
1549 case 'g': /* TBC */
1550 if (!set[0] || args[0] == 0) {
1551 terminal->tab_ruler[terminal->column] = 0;
1552 } else if (args[0] == 3) {
1553 memset(terminal->tab_ruler, 0, terminal->width);
1554 }
1555 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001556 case 'h': /* SM */
1557 for(i = 0; i < 10 && set[i]; i++) {
1558 handle_term_parameter(terminal, args[i], 1);
1559 }
1560 break;
1561 case 'l': /* RM */
1562 for(i = 0; i < 10 && set[i]; i++) {
1563 handle_term_parameter(terminal, args[i], 0);
1564 }
1565 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001566 case 'm': /* SGR */
Callum Lowcay30eeae52011-01-07 19:46:55 +00001567 for(i = 0; i < 10; i++) {
Callum Lowcay81179db2011-01-10 12:14:01 +13001568 if (i <= 7 && set[i] && set[i + 1] &&
1569 set[i + 2] && args[i + 1] == 5)
1570 {
1571 if (args[i] == 38) {
1572 handle_sgr(terminal, args[i + 2] + 256);
1573 break;
1574 } else if (args[i] == 48) {
1575 handle_sgr(terminal, args[i + 2] + 512);
1576 break;
1577 }
1578 }
Callum Lowcay30eeae52011-01-07 19:46:55 +00001579 if(set[i]) {
1580 handle_sgr(terminal, args[i]);
1581 } else if(i == 0) {
1582 handle_sgr(terminal, 0);
1583 break;
1584 } else {
1585 break;
1586 }
1587 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001588 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001589 case 'n': /* DSR */
1590 i = set[0] ? args[0] : 0;
1591 if (i == 0 || i == 5) {
Kristian Høgsberg26130862011-08-24 11:30:21 -04001592 terminal_write(terminal, "\e[0n", 4);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001593 } else if (i == 6) {
1594 snprintf(response, MAX_RESPONSE, "\e[%d;%dR",
1595 terminal->origin_mode ?
1596 terminal->row+terminal->margin_top : terminal->row+1,
1597 terminal->column+1);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001598 terminal_write(terminal, response, strlen(response));
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001599 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001600 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001601 case 'r':
1602 if(!set[0]) {
1603 terminal->margin_top = 0;
1604 terminal->margin_bottom = terminal->height-1;
1605 terminal->row = 0;
1606 terminal->column = 0;
1607 } else {
1608 top = (set[0] ? args[0] : 1) - 1;
1609 top = top < 0 ? 0 :
1610 (top >= terminal->height ? terminal->height - 1 : top);
1611 bottom = (set[1] ? args[1] : 1) - 1;
1612 bottom = bottom < 0 ? 0 :
1613 (bottom >= terminal->height ? terminal->height - 1 : bottom);
1614 if(bottom > top) {
1615 terminal->margin_top = top;
1616 terminal->margin_bottom = bottom;
1617 } else {
1618 terminal->margin_top = 0;
1619 terminal->margin_bottom = terminal->height-1;
1620 }
1621 if(terminal->origin_mode)
1622 terminal->row = terminal->margin_top;
1623 else
1624 terminal->row = 0;
1625 terminal->column = 0;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001626 }
1627 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001628 case 's':
1629 terminal->saved_row = terminal->row;
1630 terminal->saved_column = terminal->column;
1631 break;
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001632 case 't': /* windowOps */
1633 if (!set[0]) break;
1634 switch (args[0]) {
1635 case 4: /* resize px */
1636 if (set[1] && set[2]) {
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001637 widget_schedule_resize(terminal->widget,
1638 args[2], args[1]);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001639 }
1640 break;
1641 case 8: /* resize ch */
1642 if (set[1] && set[2]) {
1643 terminal_resize(terminal, args[2], args[1]);
1644 }
1645 break;
1646 case 13: /* report position */
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001647 widget_get_allocation(terminal->widget, &allocation);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001648 snprintf(response, MAX_RESPONSE, "\e[3;%d;%dt",
1649 allocation.x, allocation.y);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001650 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001651 break;
1652 case 14: /* report px */
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001653 widget_get_allocation(terminal->widget, &allocation);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001654 snprintf(response, MAX_RESPONSE, "\e[4;%d;%dt",
1655 allocation.height, allocation.width);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001656 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001657 break;
1658 case 18: /* report ch */
1659 snprintf(response, MAX_RESPONSE, "\e[9;%d;%dt",
1660 terminal->height, terminal->width);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001661 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001662 break;
1663 case 21: /* report title */
1664 snprintf(response, MAX_RESPONSE, "\e]l%s\e\\",
1665 window_get_title(terminal->window));
Kristian Høgsberg26130862011-08-24 11:30:21 -04001666 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001667 break;
1668 default:
1669 if (args[0] >= 24)
1670 terminal_resize(terminal, terminal->width, args[0]);
1671 else
1672 fprintf(stderr, "Unimplemented windowOp %d\n", args[0]);
1673 break;
1674 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001675 case 'u':
1676 terminal->row = terminal->saved_row;
1677 terminal->column = terminal->saved_column;
1678 break;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001679 default:
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001680 fprintf(stderr, "Unknown CSI escape: %c\n", *p);
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001681 break;
1682 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001683}
1684
1685static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001686handle_non_csi_escape(struct terminal *terminal, char code)
1687{
Callum Lowcaybbeac602011-01-07 19:46:58 +00001688 switch(code) {
1689 case 'M': /* RI */
1690 terminal->row -= 1;
1691 if(terminal->row < terminal->margin_top) {
1692 terminal->row = terminal->margin_top;
1693 terminal_scroll(terminal, -1);
1694 }
1695 break;
1696 case 'E': /* NEL */
1697 terminal->column = 0;
1698 // fallthrough
1699 case 'D': /* IND */
1700 terminal->row += 1;
1701 if(terminal->row > terminal->margin_bottom) {
1702 terminal->row = terminal->margin_bottom;
1703 terminal_scroll(terminal, +1);
1704 }
1705 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001706 case 'c': /* RIS */
1707 terminal_init(terminal);
1708 break;
1709 case 'H': /* HTS */
1710 terminal->tab_ruler[terminal->column] = 1;
1711 break;
1712 case '7': /* DECSC */
1713 terminal->saved_row = terminal->row;
1714 terminal->saved_column = terminal->column;
1715 terminal->saved_attr = terminal->curr_attr;
1716 terminal->saved_origin_mode = terminal->origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001717 terminal->saved_cs = terminal->cs;
1718 terminal->saved_g0 = terminal->g0;
1719 terminal->saved_g1 = terminal->g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001720 break;
1721 case '8': /* DECRC */
1722 terminal->row = terminal->saved_row;
1723 terminal->column = terminal->saved_column;
1724 terminal->curr_attr = terminal->saved_attr;
1725 terminal->origin_mode = terminal->saved_origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001726 terminal->cs = terminal->saved_cs;
1727 terminal->g0 = terminal->saved_g0;
1728 terminal->g1 = terminal->saved_g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001729 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001730 case '=': /* DECPAM */
1731 terminal->key_mode = KM_APPLICATION;
1732 break;
1733 case '>': /* DECPNM */
1734 terminal->key_mode = KM_NORMAL;
1735 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001736 default:
1737 fprintf(stderr, "Unknown escape code: %c\n", code);
1738 break;
1739 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001740}
1741
1742static void
1743handle_special_escape(struct terminal *terminal, char special, char code)
1744{
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001745 int i, numChars;
1746
1747 if (special == '#') {
1748 switch(code) {
1749 case '8':
1750 /* fill with 'E', no cheap way to do this */
1751 memset(terminal->data, 0, terminal->data_pitch * terminal->height);
1752 numChars = terminal->width * terminal->height;
1753 for(i = 0; i < numChars; i++) {
1754 terminal->data[i].byte[0] = 'E';
1755 }
1756 break;
1757 default:
1758 fprintf(stderr, "Unknown HASH escape #%c\n", code);
1759 break;
1760 }
Callum Lowcay256e72f2011-01-07 19:47:01 +00001761 } else if (special == '(' || special == ')') {
1762 switch(code) {
1763 case '0':
1764 if (special == '(')
1765 terminal->g0 = CS_SPECIAL;
1766 else
1767 terminal->g1 = CS_SPECIAL;
1768 break;
1769 case 'A':
1770 if (special == '(')
1771 terminal->g0 = CS_UK;
1772 else
1773 terminal->g1 = CS_UK;
1774 break;
1775 case 'B':
1776 if (special == '(')
1777 terminal->g0 = CS_US;
1778 else
1779 terminal->g1 = CS_US;
1780 break;
1781 default:
1782 fprintf(stderr, "Unknown character set %c\n", code);
1783 break;
1784 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001785 } else {
1786 fprintf(stderr, "Unknown special escape %c%c\n", special, code);
1787 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001788}
1789
1790static void
Callum Lowcay30eeae52011-01-07 19:46:55 +00001791handle_sgr(struct terminal *terminal, int code)
1792{
1793 switch(code) {
1794 case 0:
1795 terminal->curr_attr = terminal->color_scheme->default_attr;
1796 break;
1797 case 1:
1798 terminal->curr_attr.a |= ATTRMASK_BOLD;
1799 if (terminal->curr_attr.fg < 8)
1800 terminal->curr_attr.fg += 8;
1801 break;
1802 case 4:
1803 terminal->curr_attr.a |= ATTRMASK_UNDERLINE;
1804 break;
1805 case 5:
1806 terminal->curr_attr.a |= ATTRMASK_BLINK;
1807 break;
Callum Lowcay81179db2011-01-10 12:14:01 +13001808 case 8:
1809 terminal->curr_attr.a |= ATTRMASK_CONCEALED;
1810 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001811 case 2:
1812 case 21:
1813 case 22:
1814 terminal->curr_attr.a &= ~ATTRMASK_BOLD;
1815 if (terminal->curr_attr.fg < 16 && terminal->curr_attr.fg >= 8)
1816 terminal->curr_attr.fg -= 8;
1817 break;
1818 case 24:
1819 terminal->curr_attr.a &= ~ATTRMASK_UNDERLINE;
1820 break;
1821 case 25:
1822 terminal->curr_attr.a &= ~ATTRMASK_BLINK;
1823 break;
1824 case 7:
1825 case 26:
1826 terminal->curr_attr.a |= ATTRMASK_INVERSE;
1827 break;
1828 case 27:
1829 terminal->curr_attr.a &= ~ATTRMASK_INVERSE;
1830 break;
Callum Lowcay81179db2011-01-10 12:14:01 +13001831 case 28:
1832 terminal->curr_attr.a &= ~ATTRMASK_CONCEALED;
1833 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001834 case 39:
1835 terminal->curr_attr.fg = terminal->color_scheme->default_attr.fg;
1836 break;
1837 case 49:
1838 terminal->curr_attr.bg = terminal->color_scheme->default_attr.bg;
1839 break;
1840 default:
1841 if(code >= 30 && code <= 37) {
1842 terminal->curr_attr.fg = code - 30;
1843 if (terminal->curr_attr.a & ATTRMASK_BOLD)
1844 terminal->curr_attr.fg += 8;
1845 } else if(code >= 40 && code <= 47) {
1846 terminal->curr_attr.bg = code - 40;
Callum Lowcay81179db2011-01-10 12:14:01 +13001847 } else if (code >= 90 && code <= 97) {
1848 terminal->curr_attr.fg = code - 90 + 8;
1849 } else if (code >= 100 && code <= 107) {
1850 terminal->curr_attr.bg = code - 100 + 8;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001851 } else if(code >= 256 && code < 512) {
1852 terminal->curr_attr.fg = code - 256;
1853 } else if(code >= 512 && code < 768) {
1854 terminal->curr_attr.bg = code - 512;
1855 } else {
1856 fprintf(stderr, "Unknown SGR code: %d\n", code);
1857 }
1858 break;
1859 }
1860}
1861
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001862/* Returns 1 if c was special, otherwise 0 */
1863static int
1864handle_special_char(struct terminal *terminal, char c)
1865{
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04001866 union utf8_char *row;
1867 struct attr *attr_row;
1868
1869 row = terminal_get_row(terminal, terminal->row);
1870 attr_row = terminal_get_attr_row(terminal, terminal->row);
1871
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001872 switch(c) {
1873 case '\r':
1874 terminal->column = 0;
1875 break;
1876 case '\n':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001877 if (terminal->mode & MODE_LF_NEWLINE) {
1878 terminal->column = 0;
1879 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001880 /* fallthrough */
1881 case '\v':
1882 case '\f':
Callum Lowcaybbeac602011-01-07 19:46:58 +00001883 terminal->row++;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07001884 if (terminal->row > terminal->margin_bottom) {
Callum Lowcaybbeac602011-01-07 19:46:58 +00001885 terminal->row = terminal->margin_bottom;
1886 terminal_scroll(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001887 }
1888
1889 break;
1890 case '\t':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001891 while (terminal->column < terminal->width) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001892 if (terminal->mode & MODE_IRM)
1893 terminal_shift_line(terminal, +1);
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04001894
1895 if (row[terminal->column].byte[0] == '\0') {
1896 row[terminal->column].byte[0] = ' ';
1897 row[terminal->column].byte[1] = '\0';
1898 attr_row[terminal->column] = terminal->curr_attr;
1899 }
1900
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001901 terminal->column++;
Kristian Høgsbergcca3c2f2012-06-20 15:56:13 -04001902 if (terminal->tab_ruler[terminal->column]) break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001903 }
1904 if (terminal->column >= terminal->width) {
1905 terminal->column = terminal->width - 1;
1906 }
1907
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001908 break;
1909 case '\b':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001910 if (terminal->column >= terminal->width) {
1911 terminal->column = terminal->width - 2;
1912 } else if (terminal->column > 0) {
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001913 terminal->column--;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001914 } else if (terminal->mode & MODE_AUTOWRAP) {
1915 terminal->column = terminal->width - 1;
1916 terminal->row -= 1;
1917 if (terminal->row < terminal->margin_top) {
1918 terminal->row = terminal->margin_top;
1919 terminal_scroll(terminal, -1);
1920 }
1921 }
1922
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001923 break;
1924 case '\a':
1925 /* Bell */
1926 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001927 case '\x0E': /* SO */
1928 terminal->cs = terminal->g1;
1929 break;
1930 case '\x0F': /* SI */
1931 terminal->cs = terminal->g0;
1932 break;
Kristian Høgsberg2a1aa4e2012-08-03 09:37:05 -04001933 case '\0':
1934 break;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001935 default:
1936 return 0;
1937 }
1938
1939 return 1;
1940}
1941
1942static void
1943handle_char(struct terminal *terminal, union utf8_char utf8)
1944{
1945 union utf8_char *row;
1946 struct attr *attr_row;
1947
1948 if (handle_special_char(terminal, utf8.byte[0])) return;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001949
1950 apply_char_set(terminal->cs, &utf8);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001951
1952 /* There are a whole lot of non-characters, control codes,
1953 * and formatting codes that should probably be ignored,
1954 * for example: */
1955 if (strncmp((char*) utf8.byte, "\xEF\xBB\xBF", 3) == 0) {
1956 /* BOM, ignore */
1957 return;
1958 }
1959
1960 /* Some of these non-characters should be translated, e.g.: */
1961 if (utf8.byte[0] < 32) {
1962 utf8.byte[0] = utf8.byte[0] + 64;
1963 }
1964
1965 /* handle right margin effects */
1966 if (terminal->column >= terminal->width) {
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001967 if (terminal->mode & MODE_AUTOWRAP) {
1968 terminal->column = 0;
1969 terminal->row += 1;
1970 if (terminal->row > terminal->margin_bottom) {
1971 terminal->row = terminal->margin_bottom;
1972 terminal_scroll(terminal, +1);
1973 }
1974 } else {
1975 terminal->column--;
1976 }
1977 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001978
1979 row = terminal_get_row(terminal, terminal->row);
1980 attr_row = terminal_get_attr_row(terminal, terminal->row);
1981
Callum Lowcay69e96582011-01-07 19:47:00 +00001982 if (terminal->mode & MODE_IRM)
1983 terminal_shift_line(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001984 row[terminal->column] = utf8;
1985 attr_row[terminal->column++] = terminal->curr_attr;
1986
Kristian Høgsberg1d781ee2013-11-24 16:54:12 -08001987 if (terminal->row + terminal->start + 1 > terminal->end)
1988 terminal->end = terminal->row + terminal->start + 1;
1989 if (terminal->end == terminal->buffer_height)
1990 terminal->log_size = terminal->buffer_height;
1991 else if (terminal->log_size < terminal->buffer_height)
1992 terminal->log_size = terminal->end;
1993
Peng Wucfcc1112013-08-19 10:59:21 +08001994 /* cursor jump for wide character. */
1995 if (is_wide(utf8))
1996 row[terminal->column++].ch = 0x200B; /* space glyph */
1997
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001998 if (utf8.ch != terminal->last_char.ch)
1999 terminal->last_char = utf8;
2000}
2001
Callum Lowcay30eeae52011-01-07 19:46:55 +00002002static void
Callum Lowcay67a201d2011-01-12 19:23:41 +13002003escape_append_utf8(struct terminal *terminal, union utf8_char utf8)
2004{
2005 int len, i;
2006
2007 if ((utf8.byte[0] & 0x80) == 0x00) len = 1;
2008 else if ((utf8.byte[0] & 0xE0) == 0xC0) len = 2;
2009 else if ((utf8.byte[0] & 0xF0) == 0xE0) len = 3;
2010 else if ((utf8.byte[0] & 0xF8) == 0xF0) len = 4;
2011 else len = 1; /* Invalid, cannot happen */
2012
2013 if (terminal->escape_length + len <= MAX_ESCAPE) {
2014 for (i = 0; i < len; i++)
2015 terminal->escape[terminal->escape_length + i] = utf8.byte[i];
2016 terminal->escape_length += len;
2017 } else if (terminal->escape_length < MAX_ESCAPE) {
2018 terminal->escape[terminal->escape_length++] = 0;
2019 }
2020}
2021
2022static void
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002023terminal_data(struct terminal *terminal, const char *data, size_t length)
2024{
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002025 unsigned int i;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002026 union utf8_char utf8;
2027 enum utf8_state parser_state;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002028
2029 for (i = 0; i < length; i++) {
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002030 parser_state =
2031 utf8_next_char(&terminal->state_machine, data[i]);
2032 switch(parser_state) {
2033 case utf8state_accept:
2034 utf8.ch = terminal->state_machine.s.ch;
2035 break;
2036 case utf8state_reject:
2037 /* the unicode replacement character */
2038 utf8.byte[0] = 0xEF;
2039 utf8.byte[1] = 0xBF;
2040 utf8.byte[2] = 0xBD;
2041 utf8.byte[3] = 0x00;
2042 break;
2043 default:
2044 continue;
2045 }
2046
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002047 /* assume escape codes never use non-ASCII characters */
Callum Lowcay67a201d2011-01-12 19:23:41 +13002048 switch (terminal->state) {
2049 case escape_state_escape:
2050 escape_append_utf8(terminal, utf8);
2051 switch (utf8.byte[0]) {
2052 case 'P': /* DCS */
2053 terminal->state = escape_state_dcs;
2054 break;
2055 case '[': /* CSI */
2056 terminal->state = escape_state_csi;
2057 break;
2058 case ']': /* OSC */
2059 terminal->state = escape_state_osc;
2060 break;
2061 case '#':
2062 case '(':
2063 case ')': /* special */
2064 terminal->state = escape_state_special;
2065 break;
2066 case '^': /* PM (not implemented) */
2067 case '_': /* APC (not implemented) */
2068 terminal->state = escape_state_ignore;
2069 break;
2070 default:
2071 terminal->state = escape_state_normal;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002072 handle_non_csi_escape(terminal, utf8.byte[0]);
Callum Lowcay67a201d2011-01-12 19:23:41 +13002073 break;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002074 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13002075 continue;
2076 case escape_state_csi:
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002077 if (handle_special_char(terminal, utf8.byte[0]) != 0) {
2078 /* do nothing */
2079 } else if (utf8.byte[0] == '?') {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002080 terminal->escape_flags |= ESC_FLAG_WHAT;
2081 } else if (utf8.byte[0] == '>') {
2082 terminal->escape_flags |= ESC_FLAG_GT;
2083 } else if (utf8.byte[0] == '!') {
2084 terminal->escape_flags |= ESC_FLAG_BANG;
2085 } else if (utf8.byte[0] == '$') {
2086 terminal->escape_flags |= ESC_FLAG_CASH;
2087 } else if (utf8.byte[0] == '\'') {
2088 terminal->escape_flags |= ESC_FLAG_SQUOTE;
2089 } else if (utf8.byte[0] == '"') {
2090 terminal->escape_flags |= ESC_FLAG_DQUOTE;
2091 } else if (utf8.byte[0] == ' ') {
2092 terminal->escape_flags |= ESC_FLAG_SPACE;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002093 } else {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002094 escape_append_utf8(terminal, utf8);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002095 if (terminal->escape_length >= MAX_ESCAPE)
Callum Lowcay67a201d2011-01-12 19:23:41 +13002096 terminal->state = escape_state_normal;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002097 }
2098
2099 if (isalpha(utf8.byte[0]) || utf8.byte[0] == '@' ||
2100 utf8.byte[0] == '`')
2101 {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002102 terminal->state = escape_state_normal;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002103 handle_escape(terminal);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002104 } else {
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002105 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13002106 continue;
2107 case escape_state_inner_escape:
2108 if (utf8.byte[0] == '\\') {
2109 terminal->state = escape_state_normal;
2110 if (terminal->outer_state == escape_state_dcs) {
2111 handle_dcs(terminal);
2112 } else if (terminal->outer_state == escape_state_osc) {
2113 handle_osc(terminal);
2114 }
2115 } else if (utf8.byte[0] == '\e') {
2116 terminal->state = terminal->outer_state;
2117 escape_append_utf8(terminal, utf8);
2118 if (terminal->escape_length >= MAX_ESCAPE)
2119 terminal->state = escape_state_normal;
2120 } else {
2121 terminal->state = terminal->outer_state;
2122 if (terminal->escape_length < MAX_ESCAPE)
2123 terminal->escape[terminal->escape_length++] = '\e';
2124 escape_append_utf8(terminal, utf8);
2125 if (terminal->escape_length >= MAX_ESCAPE)
2126 terminal->state = escape_state_normal;
2127 }
2128 continue;
2129 case escape_state_dcs:
2130 case escape_state_osc:
2131 case escape_state_ignore:
2132 if (utf8.byte[0] == '\e') {
2133 terminal->outer_state = terminal->state;
2134 terminal->state = escape_state_inner_escape;
2135 } else if (utf8.byte[0] == '\a' && terminal->state == escape_state_osc) {
2136 terminal->state = escape_state_normal;
2137 handle_osc(terminal);
2138 } else {
2139 escape_append_utf8(terminal, utf8);
2140 if (terminal->escape_length >= MAX_ESCAPE)
2141 terminal->state = escape_state_normal;
2142 }
2143 continue;
2144 case escape_state_special:
2145 escape_append_utf8(terminal, utf8);
2146 terminal->state = escape_state_normal;
2147 if (isdigit(utf8.byte[0]) || isalpha(utf8.byte[0])) {
2148 handle_special_escape(terminal, terminal->escape[1],
2149 utf8.byte[0]);
2150 }
2151 continue;
2152 default:
2153 break;
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05002154 }
2155
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002156 /* this is valid, because ASCII characters are never used to
2157 * introduce a multibyte sequence in UTF-8 */
2158 if (utf8.byte[0] == '\e') {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002159 terminal->state = escape_state_escape;
2160 terminal->outer_state = escape_state_normal;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002161 terminal->escape[0] = '\e';
2162 terminal->escape_length = 1;
Callum Lowcay67a201d2011-01-12 19:23:41 +13002163 terminal->escape_flags = 0;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002164 } else {
2165 handle_char(terminal, utf8);
2166 } /* if */
2167 } /* for */
Kristian Høgsberg721f09f2008-12-08 11:13:26 -05002168
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04002169 window_schedule_redraw(terminal->window);
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002170}
2171
2172static void
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002173data_source_target(void *data,
2174 struct wl_data_source *source, const char *mime_type)
2175{
2176 fprintf(stderr, "data_source_target, %s\n", mime_type);
2177}
2178
2179static void
2180data_source_send(void *data,
2181 struct wl_data_source *source,
2182 const char *mime_type, int32_t fd)
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002183{
Kristian Høgsberg31cce052011-01-21 15:18:55 -05002184 struct terminal *terminal = data;
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002185
Kristian Høgsberg31cce052011-01-21 15:18:55 -05002186 terminal_send_selection(terminal, fd);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002187}
2188
2189static void
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002190data_source_cancelled(void *data, struct wl_data_source *source)
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002191{
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002192 wl_data_source_destroy(source);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002193}
2194
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002195static const struct wl_data_source_listener data_source_listener = {
2196 data_source_target,
2197 data_source_send,
2198 data_source_cancelled
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002199};
2200
Kristian Høgsberg0749e3f2013-09-04 20:41:06 -07002201static const char text_mime_type[] = "text/plain;charset=utf-8";
2202
2203static void
2204data_handler(struct window *window,
2205 struct input *input,
2206 float x, float y, const char **types, void *data)
2207{
2208 int i, has_text = 0;
2209
2210 if (!types)
2211 return;
2212 for (i = 0; types[i]; i++)
2213 if (strcmp(types[i], text_mime_type) == 0)
2214 has_text = 1;
2215
2216 if (!has_text) {
2217 input_accept(input, NULL);
2218 } else {
2219 input_accept(input, text_mime_type);
2220 }
2221}
2222
2223static void
2224drop_handler(struct window *window, struct input *input,
2225 int32_t x, int32_t y, void *data)
2226{
2227 struct terminal *terminal = data;
2228
2229 input_receive_drag_data_to_fd(input, text_mime_type, terminal->master);
2230}
2231
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002232static void
2233fullscreen_handler(struct window *window, void *data)
2234{
2235 struct terminal *terminal = data;
2236
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002237 window_set_fullscreen(window, !window_is_fullscreen(terminal->window));
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002238}
2239
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002240static void
Jasper St. Pierrebf175902013-11-12 20:19:58 -05002241close_handler(void *data)
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002242{
2243 struct terminal *terminal = data;
2244
2245 terminal_destroy(terminal);
2246}
2247
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002248static void
2249terminal_copy(struct terminal *terminal, struct input *input)
2250{
2251 terminal->selection =
2252 display_create_data_source(terminal->display);
2253 wl_data_source_offer(terminal->selection,
2254 "text/plain;charset=utf-8");
2255 wl_data_source_add_listener(terminal->selection,
2256 &data_source_listener, terminal);
2257 input_set_selection(input, terminal->selection,
2258 display_get_serial(terminal->display));
2259}
2260
2261static void
2262terminal_paste(struct terminal *terminal, struct input *input)
2263{
2264 input_receive_selection_data_to_fd(input,
2265 "text/plain;charset=utf-8",
2266 terminal->master);
2267
2268}
2269
2270static void
2271terminal_new_instance(struct terminal *terminal)
2272{
2273 struct terminal *new_terminal;
2274
2275 new_terminal = terminal_create(terminal->display);
2276 if (terminal_run(new_terminal, option_shell))
2277 terminal_destroy(new_terminal);
2278}
2279
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002280static int
2281handle_bound_key(struct terminal *terminal,
2282 struct input *input, uint32_t sym, uint32_t time)
2283{
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002284 switch (sym) {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002285 case XKB_KEY_X:
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002286 /* Cut selection; terminal doesn't do cut, fall
2287 * through to copy. */
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002288 case XKB_KEY_C:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002289 terminal_copy(terminal, input);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002290 return 1;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002291 case XKB_KEY_V:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002292 terminal_paste(terminal, input);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002293 return 1;
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002294 case XKB_KEY_N:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002295 terminal_new_instance(terminal);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002296 return 1;
2297
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002298 case XKB_KEY_Up:
2299 if (!terminal->scrolling)
2300 terminal->saved_start = terminal->start;
2301 if (terminal->start == terminal->end - terminal->log_size)
2302 return 1;
2303
2304 terminal->scrolling = 1;
2305 terminal->start--;
2306 terminal->row++;
2307 terminal->selection_start_row++;
2308 terminal->selection_end_row++;
2309 widget_schedule_redraw(terminal->widget);
2310 return 1;
2311
2312 case XKB_KEY_Down:
2313 if (!terminal->scrolling)
2314 terminal->saved_start = terminal->start;
2315
2316 if (terminal->start == terminal->saved_start)
2317 return 1;
2318
2319 terminal->scrolling = 1;
2320 terminal->start++;
2321 terminal->row--;
2322 terminal->selection_start_row--;
2323 terminal->selection_end_row--;
2324 widget_schedule_redraw(terminal->widget);
2325 return 1;
2326
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002327 default:
2328 return 0;
2329 }
2330}
2331
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002332static void
2333key_handler(struct window *window, struct input *input, uint32_t time,
Daniel Stonec9785ea2012-05-30 16:31:52 +01002334 uint32_t key, uint32_t sym, enum wl_keyboard_key_state state,
2335 void *data)
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002336{
2337 struct terminal *terminal = data;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00002338 char ch[MAX_RESPONSE];
Kristian Høgsberg88fd4082012-06-21 15:55:03 -04002339 uint32_t modifiers, serial;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002340 int ret, len = 0, d;
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002341 bool convert_utf8 = true;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002342
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002343 modifiers = input_get_modifiers(input);
Kristian Høgsberg70163132012-05-08 15:55:39 -04002344 if ((modifiers & MOD_CONTROL_MASK) &&
2345 (modifiers & MOD_SHIFT_MASK) &&
Daniel Stonec9785ea2012-05-30 16:31:52 +01002346 state == WL_KEYBOARD_KEY_STATE_PRESSED &&
2347 handle_bound_key(terminal, input, sym, time))
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002348 return;
2349
Daniel Stonea8468712012-11-07 17:51:35 +11002350 /* Map keypad symbols to 'normal' equivalents before processing */
2351 switch (sym) {
2352 case XKB_KEY_KP_Space:
2353 sym = XKB_KEY_space;
2354 break;
2355 case XKB_KEY_KP_Tab:
2356 sym = XKB_KEY_Tab;
2357 break;
2358 case XKB_KEY_KP_Enter:
2359 sym = XKB_KEY_Return;
2360 break;
2361 case XKB_KEY_KP_Left:
2362 sym = XKB_KEY_Left;
2363 break;
2364 case XKB_KEY_KP_Up:
2365 sym = XKB_KEY_Up;
2366 break;
2367 case XKB_KEY_KP_Right:
2368 sym = XKB_KEY_Right;
2369 break;
2370 case XKB_KEY_KP_Down:
2371 sym = XKB_KEY_Down;
2372 break;
2373 case XKB_KEY_KP_Equal:
2374 sym = XKB_KEY_equal;
2375 break;
2376 case XKB_KEY_KP_Multiply:
2377 sym = XKB_KEY_asterisk;
2378 break;
2379 case XKB_KEY_KP_Add:
2380 sym = XKB_KEY_plus;
2381 break;
2382 case XKB_KEY_KP_Separator:
2383 /* Note this is actually locale-dependent and should mostly be
2384 * a comma. But leave it as period until we one day start
2385 * doing the right thing. */
2386 sym = XKB_KEY_period;
2387 break;
2388 case XKB_KEY_KP_Subtract:
2389 sym = XKB_KEY_minus;
2390 break;
2391 case XKB_KEY_KP_Decimal:
2392 sym = XKB_KEY_period;
2393 break;
2394 case XKB_KEY_KP_Divide:
2395 sym = XKB_KEY_slash;
2396 break;
2397 case XKB_KEY_KP_0:
2398 case XKB_KEY_KP_1:
2399 case XKB_KEY_KP_2:
2400 case XKB_KEY_KP_3:
2401 case XKB_KEY_KP_4:
2402 case XKB_KEY_KP_5:
2403 case XKB_KEY_KP_6:
2404 case XKB_KEY_KP_7:
2405 case XKB_KEY_KP_8:
2406 case XKB_KEY_KP_9:
2407 sym = (sym - XKB_KEY_KP_0) + XKB_KEY_0;
2408 break;
2409 default:
2410 break;
2411 }
2412
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002413 switch (sym) {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002414 case XKB_KEY_BackSpace:
Kristian Høgsbergb7f94bf2012-06-21 12:29:36 -04002415 if (modifiers & MOD_ALT_MASK)
2416 ch[len++] = 0x1b;
Kristian Høgsberg71a4cf42012-06-20 17:57:56 -04002417 ch[len++] = 0x7f;
2418 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002419 case XKB_KEY_Tab:
2420 case XKB_KEY_Linefeed:
2421 case XKB_KEY_Clear:
2422 case XKB_KEY_Pause:
2423 case XKB_KEY_Scroll_Lock:
2424 case XKB_KEY_Sys_Req:
2425 case XKB_KEY_Escape:
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002426 ch[len++] = sym & 0x7f;
2427 break;
2428
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002429 case XKB_KEY_Return:
Callum Lowcay8e57dd52011-01-07 19:46:59 +00002430 if (terminal->mode & MODE_LF_NEWLINE) {
2431 ch[len++] = 0x0D;
2432 ch[len++] = 0x0A;
2433 } else {
2434 ch[len++] = 0x0D;
2435 }
2436 break;
2437
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002438 case XKB_KEY_Shift_L:
2439 case XKB_KEY_Shift_R:
2440 case XKB_KEY_Control_L:
2441 case XKB_KEY_Control_R:
2442 case XKB_KEY_Alt_L:
2443 case XKB_KEY_Alt_R:
Kristian Høgsberg22fbcf72012-06-22 12:18:56 -04002444 case XKB_KEY_Meta_L:
2445 case XKB_KEY_Meta_R:
2446 case XKB_KEY_Super_L:
2447 case XKB_KEY_Super_R:
2448 case XKB_KEY_Hyper_L:
2449 case XKB_KEY_Hyper_R:
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002450 break;
2451
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002452 case XKB_KEY_Insert:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002453 len = function_key_response('[', 2, modifiers, '~', ch);
2454 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002455 case XKB_KEY_Delete:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002456 if (terminal->mode & MODE_DELETE_SENDS_DEL) {
2457 ch[len++] = '\x04';
2458 } else {
2459 len = function_key_response('[', 3, modifiers, '~', ch);
2460 }
2461 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002462 case XKB_KEY_Page_Up:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002463 len = function_key_response('[', 5, modifiers, '~', ch);
2464 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002465 case XKB_KEY_Page_Down:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002466 len = function_key_response('[', 6, modifiers, '~', ch);
2467 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002468 case XKB_KEY_F1:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002469 len = function_key_response('O', 1, modifiers, 'P', ch);
2470 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002471 case XKB_KEY_F2:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002472 len = function_key_response('O', 1, modifiers, 'Q', ch);
2473 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002474 case XKB_KEY_F3:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002475 len = function_key_response('O', 1, modifiers, 'R', ch);
2476 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002477 case XKB_KEY_F4:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002478 len = function_key_response('O', 1, modifiers, 'S', ch);
2479 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002480 case XKB_KEY_F5:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002481 len = function_key_response('[', 15, modifiers, '~', ch);
2482 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002483 case XKB_KEY_F6:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002484 len = function_key_response('[', 17, modifiers, '~', ch);
2485 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002486 case XKB_KEY_F7:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002487 len = function_key_response('[', 18, modifiers, '~', ch);
2488 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002489 case XKB_KEY_F8:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002490 len = function_key_response('[', 19, modifiers, '~', ch);
2491 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002492 case XKB_KEY_F9:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002493 len = function_key_response('[', 20, modifiers, '~', ch);
2494 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002495 case XKB_KEY_F10:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002496 len = function_key_response('[', 21, modifiers, '~', ch);
2497 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002498 case XKB_KEY_F12:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002499 len = function_key_response('[', 24, modifiers, '~', ch);
2500 break;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002501 default:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002502 /* Handle special keys with alternate mappings */
2503 len = apply_key_map(terminal->key_mode, sym, modifiers, ch);
2504 if (len != 0) break;
2505
Kristian Høgsberg70163132012-05-08 15:55:39 -04002506 if (modifiers & MOD_CONTROL_MASK) {
Callum Lowcay7e08e902011-01-07 19:47:02 +00002507 if (sym >= '3' && sym <= '7')
2508 sym = (sym & 0x1f) + 8;
2509
2510 if (!((sym >= '!' && sym <= '/') ||
2511 (sym >= '8' && sym <= '?') ||
2512 (sym >= '0' && sym <= '2'))) sym = sym & 0x1f;
2513 else if (sym == '2') sym = 0x00;
2514 else if (sym == '/') sym = 0x1F;
2515 else if (sym == '8' || sym == '?') sym = 0x7F;
Kristian Høgsbergae9e0732012-06-21 12:30:15 -04002516 }
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002517 if (modifiers & MOD_ALT_MASK) {
2518 if (terminal->mode & MODE_ALT_SENDS_ESC) {
2519 ch[len++] = 0x1b;
2520 } else {
2521 sym = sym | 0x80;
2522 convert_utf8 = false;
2523 }
Callum Lowcay7e08e902011-01-07 19:47:02 +00002524 }
2525
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002526 if ((sym < 128) ||
2527 (!convert_utf8 && sym < 256)) {
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002528 ch[len++] = sym;
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002529 } else {
2530 ret = xkb_keysym_to_utf8(sym, ch + len,
2531 MAX_RESPONSE - len);
2532 if (ret < 0)
2533 fprintf(stderr,
2534 "Warning: buffer too small to encode "
2535 "UTF8 character\n");
2536 else
2537 len += ret;
2538 }
2539
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002540 break;
2541 }
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002542
Kristian Høgsbergb24ab802012-06-22 12:17:17 -04002543 if (state == WL_KEYBOARD_KEY_STATE_PRESSED && len > 0) {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002544 if (terminal->scrolling) {
2545 d = terminal->saved_start - terminal->start;
2546 terminal->row -= d;
2547 terminal->selection_start_row -= d;
2548 terminal->selection_end_row -= d;
2549 terminal->start = terminal->saved_start;
2550 terminal->scrolling = 0;
2551 widget_schedule_redraw(terminal->widget);
2552 }
2553
Kristian Høgsberg26130862011-08-24 11:30:21 -04002554 terminal_write(terminal, ch, len);
Kristian Høgsbergb24ab802012-06-22 12:17:17 -04002555
2556 /* Hide cursor, except if this was coming from a
2557 * repeating key press. */
2558 serial = display_get_serial(terminal->display);
2559 if (terminal->hide_cursor_serial != serial) {
2560 input_set_pointer_image(input, CURSOR_BLANK);
2561 terminal->hide_cursor_serial = serial;
2562 }
2563 }
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002564}
2565
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002566static void
2567keyboard_focus_handler(struct window *window,
Kristian Høgsberg43788b12010-07-28 23:50:12 -04002568 struct input *device, void *data)
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002569{
2570 struct terminal *terminal = data;
2571
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04002572 window_schedule_redraw(terminal->window);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002573}
2574
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002575static int wordsep(int ch)
2576{
2577 const char extra[] = "-,./?%&#:_=+@~";
2578
Andre Heider552d12b2012-08-02 20:59:43 +02002579 if (ch > 127)
2580 return 1;
2581
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002582 return ch == 0 || !(isalpha(ch) || isdigit(ch) || strchr(extra, ch));
2583}
2584
2585static int
2586recompute_selection(struct terminal *terminal)
2587{
2588 struct rectangle allocation;
2589 int col, x, width, height;
2590 int start_row, end_row;
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002591 int word_start, eol;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002592 int side_margin, top_margin;
2593 int start_x, end_x;
2594 int cw, ch;
2595 union utf8_char *data;
2596
Peng Wuf291f202013-06-06 15:32:41 +08002597 cw = terminal->average_width;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002598 ch = terminal->extents.height;
2599 widget_get_allocation(terminal->widget, &allocation);
2600 width = terminal->width * cw;
2601 height = terminal->height * ch;
2602 side_margin = allocation.x + (allocation.width - width) / 2;
2603 top_margin = allocation.y + (allocation.height - height) / 2;
2604
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002605 start_row = (terminal->selection_start_y - top_margin + ch) / ch - 1;
2606 end_row = (terminal->selection_end_y - top_margin + ch) / ch - 1;
2607
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002608 if (start_row < end_row ||
2609 (start_row == end_row &&
2610 terminal->selection_start_x < terminal->selection_end_x)) {
2611 terminal->selection_start_row = start_row;
2612 terminal->selection_end_row = end_row;
2613 start_x = terminal->selection_start_x;
2614 end_x = terminal->selection_end_x;
2615 } else {
2616 terminal->selection_start_row = end_row;
2617 terminal->selection_end_row = start_row;
2618 start_x = terminal->selection_end_x;
2619 end_x = terminal->selection_start_x;
2620 }
2621
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002622 eol = 0;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002623 if (terminal->selection_start_row < 0) {
2624 terminal->selection_start_row = 0;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002625 terminal->selection_start_col = 0;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002626 } else {
2627 x = side_margin + cw / 2;
2628 data = terminal_get_row(terminal,
2629 terminal->selection_start_row);
2630 word_start = 0;
2631 for (col = 0; col < terminal->width; col++, x += cw) {
2632 if (col == 0 || wordsep(data[col - 1].ch))
2633 word_start = col;
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002634 if (data[col].ch != 0)
2635 eol = col + 1;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002636 if (start_x < x)
2637 break;
2638 }
2639
2640 switch (terminal->dragging) {
2641 case SELECT_LINE:
2642 terminal->selection_start_col = 0;
2643 break;
2644 case SELECT_WORD:
2645 terminal->selection_start_col = word_start;
2646 break;
2647 case SELECT_CHAR:
2648 terminal->selection_start_col = col;
2649 break;
2650 }
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002651 }
2652
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002653 if (terminal->selection_end_row >= terminal->height) {
2654 terminal->selection_end_row = terminal->height;
2655 terminal->selection_end_col = 0;
2656 } else {
2657 x = side_margin + cw / 2;
2658 data = terminal_get_row(terminal, terminal->selection_end_row);
2659 for (col = 0; col < terminal->width; col++, x += cw) {
2660 if (terminal->dragging == SELECT_CHAR && end_x < x)
2661 break;
2662 if (terminal->dragging == SELECT_WORD &&
2663 end_x < x && wordsep(data[col].ch))
2664 break;
2665 }
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002666 terminal->selection_end_col = col;
2667 }
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002668
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002669 if (terminal->selection_end_col != terminal->selection_start_col ||
2670 terminal->selection_start_row != terminal->selection_end_row) {
2671 col = terminal->selection_end_col;
2672 if (col > 0 && data[col - 1].ch == 0)
2673 terminal->selection_end_col = terminal->width;
2674 data = terminal_get_row(terminal, terminal->selection_start_row);
2675 if (data[terminal->selection_start_col].ch == 0)
2676 terminal->selection_start_col = eol;
2677 }
2678
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002679 return 1;
2680}
2681
Kristian Høgsberg59826582011-01-20 11:56:57 -05002682static void
Jasper St. Pierredda93132014-03-13 12:06:00 -04002683menu_func(void *data, struct input *input, int index)
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002684{
Jasper St. Pierredda93132014-03-13 12:06:00 -04002685 struct window *window = data;
2686 struct terminal *terminal = window_get_user_data(window);
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002687
2688 fprintf(stderr, "picked entry %d\n", index);
2689
2690 switch (index) {
2691 case 0:
2692 terminal_new_instance(terminal);
2693 break;
2694 case 1:
2695 terminal_copy(terminal, input);
2696 break;
2697 case 2:
2698 terminal_paste(terminal, input);
2699 break;
2700 }
2701}
2702
2703static void
2704show_menu(struct terminal *terminal, struct input *input, uint32_t time)
2705{
2706 int32_t x, y;
2707 static const char *entries[] = {
2708 "Open Terminal", "Copy", "Paste"
2709 };
2710
2711 input_get_position(input, &x, &y);
2712 window_show_menu(terminal->display, input, time, terminal->window,
2713 x - 10, y - 10, menu_func,
2714 entries, ARRAY_LENGTH(entries));
2715}
2716
2717static void
Xiong Zhang49c6aee2013-11-25 18:42:52 +08002718click_handler(struct widget *widget, struct terminal *terminal,
2719 struct input *input, int32_t x, int32_t y,
2720 uint32_t time)
2721{
2722 if (time - terminal->click_time < 500)
2723 terminal->click_count++;
2724 else
2725 terminal->click_count = 1;
2726
2727 terminal->click_time = time;
2728 terminal->dragging = (terminal->click_count - 1) % 3 + SELECT_CHAR;
2729
2730 terminal->selection_end_x = terminal->selection_start_x = x;
2731 terminal->selection_end_y = terminal->selection_start_y = y;
2732 if (recompute_selection(terminal))
2733 widget_schedule_redraw(widget);
2734}
2735
2736static void
Kristian Høgsberga8a0db32012-01-09 11:12:05 -05002737button_handler(struct widget *widget,
Kristian Høgsberg59826582011-01-20 11:56:57 -05002738 struct input *input, uint32_t time,
Daniel Stone4dbadb12012-05-30 16:31:51 +01002739 uint32_t button,
2740 enum wl_pointer_button_state state, void *data)
Kristian Høgsberg59826582011-01-20 11:56:57 -05002741{
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002742 struct terminal *terminal = data;
Xiong Zhang49c6aee2013-11-25 18:42:52 +08002743 int32_t x, y;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002744
2745 switch (button) {
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002746 case BTN_LEFT:
Daniel Stone4dbadb12012-05-30 16:31:51 +01002747 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
Xiong Zhang49c6aee2013-11-25 18:42:52 +08002748 input_get_position(input, &x, &y);
2749 click_handler(widget, terminal, input, x, y, time);
Kristian Høgsberg59826582011-01-20 11:56:57 -05002750 } else {
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002751 terminal->dragging = SELECT_NONE;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002752 }
2753 break;
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002754
2755 case BTN_RIGHT:
2756 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
2757 show_menu(terminal, input, time);
2758 break;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002759 }
2760}
2761
2762static int
Kristian Høgsberg29784402012-06-28 14:27:02 -04002763enter_handler(struct widget *widget,
2764 struct input *input, float x, float y, void *data)
2765{
2766 return CURSOR_IBEAM;
2767}
2768
2769static int
Kristian Høgsberg5f190ef2012-01-09 09:44:45 -05002770motion_handler(struct widget *widget,
Kristian Høgsberg59826582011-01-20 11:56:57 -05002771 struct input *input, uint32_t time,
Kristian Høgsberg80680c72012-05-10 12:21:37 -04002772 float x, float y, void *data)
Kristian Høgsberg59826582011-01-20 11:56:57 -05002773{
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002774 struct terminal *terminal = data;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002775
2776 if (terminal->dragging) {
Kristian Høgsberg59826582011-01-20 11:56:57 -05002777 input_get_position(input,
2778 &terminal->selection_end_x,
2779 &terminal->selection_end_y);
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002780
2781 if (recompute_selection(terminal))
2782 widget_schedule_redraw(widget);
Kristian Høgsberg59826582011-01-20 11:56:57 -05002783 }
2784
Ander Conselvan de Oliveiradc8c8fc2012-05-25 16:01:41 +03002785 return CURSOR_IBEAM;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002786}
2787
Alexander Larssonde79dd02013-05-22 14:41:34 +02002788static void
2789output_handler(struct window *window, struct output *output, int enter,
2790 void *data)
2791{
2792 if (enter)
2793 window_set_buffer_transform(window, output_get_transform(output));
2794 window_set_buffer_scale(window, window_get_output_scale(window));
2795 window_schedule_redraw(window);
2796}
2797
Xiong Zhang49c6aee2013-11-25 18:42:52 +08002798static void
2799touch_down_handler(struct widget *widget, struct input *input,
2800 uint32_t serial, uint32_t time, int32_t id,
2801 float x, float y, void *data)
2802{
2803 struct terminal *terminal = data;
2804
2805 if (id == 0)
2806 click_handler(widget, terminal, input, x, y, time);
2807}
2808
2809static void
2810touch_up_handler(struct widget *widget, struct input *input,
2811 uint32_t serial, uint32_t time, int32_t id, void *data)
2812{
2813 struct terminal *terminal = data;
2814
2815 if (id == 0)
2816 terminal->dragging = SELECT_NONE;
2817}
2818
2819static void
2820touch_motion_handler(struct widget *widget, struct input *input,
2821 uint32_t time, int32_t id, float x, float y, void *data)
2822{
2823 struct terminal *terminal = data;
2824
2825 if (terminal->dragging &&
2826 id == 0) {
2827 terminal->selection_end_x = (int)x;
2828 terminal->selection_end_y = (int)y;
2829
2830 if (recompute_selection(terminal))
2831 widget_schedule_redraw(widget);
2832 }
2833}
2834
Peng Wuf291f202013-06-06 15:32:41 +08002835#ifndef howmany
2836#define howmany(x, y) (((x) + ((y) - 1)) / (y))
2837#endif
2838
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002839static struct terminal *
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002840terminal_create(struct display *display)
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002841{
2842 struct terminal *terminal;
Kristian Høgsberg09531622010-06-14 23:22:15 -04002843 cairo_surface_t *surface;
2844 cairo_t *cr;
Peng Wuf291f202013-06-06 15:32:41 +08002845 cairo_text_extents_t text_extents;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002846
Peter Huttererf3d62272013-08-08 11:57:05 +10002847 terminal = xzalloc(sizeof *terminal);
Callum Lowcay30eeae52011-01-07 19:46:55 +00002848 terminal->color_scheme = &DEFAULT_COLORS;
2849 terminal_init(terminal);
Callum Lowcaybbeac602011-01-07 19:46:58 +00002850 terminal->margin_top = 0;
Callum Lowcay86653ed2011-01-07 19:47:03 +00002851 terminal->margin_bottom = -1;
Kristian Høgsberg009ac0a2012-01-31 15:24:48 -05002852 terminal->window = window_create(display);
Jason Ekstrandee7fefc2013-10-13 19:08:38 -05002853 terminal->widget = window_frame_create(terminal->window, terminal);
U. Artie Eoff09827e22014-01-15 11:40:37 -08002854 terminal->title = xstrdup("Wayland Terminal");
Kristian Høgsberga83be202013-10-23 20:47:35 -07002855 window_set_title(terminal->window, terminal->title);
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05002856 widget_set_transparent(terminal->widget, 0);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002857
2858 init_state_machine(&terminal->state_machine);
Callum Lowcay30eeae52011-01-07 19:46:55 +00002859 init_color_table(terminal);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002860
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002861 terminal->display = display;
Kristian Høgsberg1584c572008-12-08 12:59:37 -05002862 terminal->margin = 5;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002863 terminal->buffer_height = 1024;
2864 terminal->end = 1;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05002865
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002866 window_set_user_data(terminal->window, terminal);
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002867 window_set_key_handler(terminal->window, key_handler);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002868 window_set_keyboard_focus_handler(terminal->window,
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002869 keyboard_focus_handler);
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002870 window_set_fullscreen_handler(terminal->window, fullscreen_handler);
Alexander Larssonde79dd02013-05-22 14:41:34 +02002871 window_set_output_handler(terminal->window, output_handler);
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002872 window_set_close_handler(terminal->window, close_handler);
Jasper St. Pierrede680992014-04-10 17:23:49 -07002873 window_set_state_changed_handler(terminal->window, state_changed_handler);
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002874
Kristian Høgsberg0749e3f2013-09-04 20:41:06 -07002875 window_set_data_handler(terminal->window, data_handler);
2876 window_set_drop_handler(terminal->window, drop_handler);
2877
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05002878 widget_set_redraw_handler(terminal->widget, redraw_handler);
2879 widget_set_resize_handler(terminal->widget, resize_handler);
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002880 widget_set_button_handler(terminal->widget, button_handler);
Kristian Høgsberg29784402012-06-28 14:27:02 -04002881 widget_set_enter_handler(terminal->widget, enter_handler);
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002882 widget_set_motion_handler(terminal->widget, motion_handler);
Xiong Zhang49c6aee2013-11-25 18:42:52 +08002883 widget_set_touch_up_handler(terminal->widget, touch_up_handler);
2884 widget_set_touch_down_handler(terminal->widget, touch_down_handler);
2885 widget_set_touch_motion_handler(terminal->widget, touch_motion_handler);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002886
Kristian Høgsberg09531622010-06-14 23:22:15 -04002887 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
2888 cr = cairo_create(surface);
Kristian Høgsberg38912df2012-06-27 17:52:23 -04002889 cairo_set_font_size(cr, option_font_size);
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002890 cairo_select_font_face (cr, option_font,
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05002891 CAIRO_FONT_SLANT_NORMAL,
2892 CAIRO_FONT_WEIGHT_BOLD);
2893 terminal->font_bold = cairo_get_scaled_font (cr);
2894 cairo_scaled_font_reference(terminal->font_bold);
2895
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002896 cairo_select_font_face (cr, option_font,
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05002897 CAIRO_FONT_SLANT_NORMAL,
2898 CAIRO_FONT_WEIGHT_NORMAL);
2899 terminal->font_normal = cairo_get_scaled_font (cr);
2900 cairo_scaled_font_reference(terminal->font_normal);
2901
Kristian Høgsberg09531622010-06-14 23:22:15 -04002902 cairo_font_extents(cr, &terminal->extents);
Peng Wuf291f202013-06-06 15:32:41 +08002903
2904 /* Compute the average ascii glyph width */
2905 cairo_text_extents(cr, TERMINAL_DRAW_SINGLE_WIDE_CHARACTERS,
2906 &text_extents);
2907 terminal->average_width = howmany
2908 (text_extents.width,
2909 strlen(TERMINAL_DRAW_SINGLE_WIDE_CHARACTERS));
2910 terminal->average_width = ceil(terminal->average_width);
2911
Kristian Høgsberg09531622010-06-14 23:22:15 -04002912 cairo_destroy(cr);
2913 cairo_surface_destroy(surface);
2914
Kristian Høgsbergd3a19652012-07-20 11:32:51 -04002915 terminal_resize(terminal, 20, 5); /* Set minimum size first */
Kristian Høgsberga1627922012-06-20 17:30:03 -04002916 terminal_resize(terminal, 80, 25);
Kristian Høgsberg009ac0a2012-01-31 15:24:48 -05002917
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002918 wl_list_insert(terminal_list.prev, &terminal->link);
2919
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002920 return terminal;
2921}
2922
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002923static void
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002924terminal_destroy(struct terminal *terminal)
2925{
Dima Ryazanova85292e2012-11-29 00:27:09 -08002926 display_unwatch_fd(terminal->display, terminal->master);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002927 window_destroy(terminal->window);
2928 close(terminal->master);
2929 wl_list_remove(&terminal->link);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002930
2931 if (wl_list_empty(&terminal_list))
Dima Ryazanova85292e2012-11-29 00:27:09 -08002932 display_exit(terminal->display);
2933
Kristian Høgsberga83be202013-10-23 20:47:35 -07002934 free(terminal->title);
Dima Ryazanova85292e2012-11-29 00:27:09 -08002935 free(terminal);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002936}
2937
2938static void
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002939io_handler(struct task *task, uint32_t events)
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002940{
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002941 struct terminal *terminal =
2942 container_of(task, struct terminal, io_task);
2943 char buffer[256];
2944 int len;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002945
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002946 if (events & EPOLLHUP) {
2947 terminal_destroy(terminal);
2948 return;
2949 }
Tim Wiederhakef71accc2011-01-19 23:14:33 +01002950
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002951 len = read(terminal->master, buffer, sizeof buffer);
2952 if (len < 0)
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002953 terminal_destroy(terminal);
2954 else
2955 terminal_data(terminal, buffer, len);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002956}
2957
2958static int
2959terminal_run(struct terminal *terminal, const char *path)
2960{
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05002961 int master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002962 pid_t pid;
2963
2964 pid = forkpty(&master, NULL, NULL, NULL);
2965 if (pid == 0) {
Kristian Høgsbergde845cf2012-06-20 22:14:31 -04002966 setenv("TERM", option_term, 1);
2967 setenv("COLORTERM", option_term, 1);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002968 if (execl(path, path, NULL)) {
2969 printf("exec failed: %m\n");
2970 exit(EXIT_FAILURE);
2971 }
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05002972 } else if (pid < 0) {
2973 fprintf(stderr, "failed to fork and create pty (%m).\n");
2974 return -1;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002975 }
2976
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002977 terminal->master = master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002978 fcntl(master, F_SETFL, O_NONBLOCK);
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002979 terminal->io_task.run = io_handler;
2980 display_watch_fd(terminal->display, terminal->master,
2981 EPOLLIN | EPOLLHUP, &terminal->io_task);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002982
Kristian Høgsbergcdbbae22014-04-07 11:28:05 -07002983 if (option_fullscreen)
2984 window_set_fullscreen(terminal->window, 1);
2985 else
Kristian Høgsberg547da5a2011-09-13 20:58:00 -04002986 terminal_resize(terminal, 80, 24);
2987
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002988 return 0;
2989}
2990
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002991static const struct weston_option terminal_options[] = {
2992 { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &option_fullscreen },
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002993 { WESTON_OPTION_STRING, "font", 0, &option_font },
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002994 { WESTON_OPTION_STRING, "shell", 0, &option_shell },
Kristian Høgsberg0395f302008-12-22 12:14:50 -05002995};
2996
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002997int main(int argc, char *argv[])
2998{
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05002999 struct display *d;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05003000 struct terminal *terminal;
Kristian Høgsberg9c3dee12013-09-21 22:23:08 -07003001 struct weston_config *config;
3002 struct weston_config_section *s;
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04003003
Peng Wucfcc1112013-08-19 10:59:21 +08003004 /* as wcwidth is locale-dependent,
3005 wcwidth needs setlocale call to function properly. */
3006 setlocale(LC_ALL, "");
3007
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04003008 option_shell = getenv("SHELL");
3009 if (!option_shell)
3010 option_shell = "/bin/bash";
3011
Kristian Høgsberg1abe0482013-09-21 23:02:31 -07003012 config = weston_config_parse("weston.ini");
Kristian Høgsberg9c3dee12013-09-21 22:23:08 -07003013 s = weston_config_get_section(config, "terminal", NULL, NULL);
3014 weston_config_section_get_string(s, "font", &option_font, "mono");
3015 weston_config_section_get_int(s, "font-size", &option_font_size, 14);
3016 weston_config_section_get_string(s, "term", &option_term, "xterm");
3017 weston_config_destroy(config);
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003018
Kristian Høgsberg4172f662013-02-20 15:27:49 -05003019 d = display_create(&argc, argv);
Yuval Fledele9f5e362010-11-22 21:34:19 +02003020 if (d == NULL) {
3021 fprintf(stderr, "failed to create display: %m\n");
3022 return -1;
3023 }
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05003024
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04003025 wl_list_init(&terminal_list);
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04003026 terminal = terminal_create(d);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04003027 if (terminal_run(terminal, option_shell))
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05003028 exit(EXIT_FAILURE);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05003029
Kristian Høgsberg7824d812010-06-08 14:59:44 -04003030 display_run(d);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05003031
3032 return 0;
3033}