blob: e7dcd91a9ce63e8fe5722aa3591a21c364ef7986 [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øgsberg58eec362011-01-19 14:27:42 -0500468
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -0400469 struct wl_data_source *selection;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400470 uint32_t button_time;
471 int dragging, click_count;
Kristian Høgsberg59826582011-01-20 11:56:57 -0500472 int selection_start_x, selection_start_y;
473 int selection_end_x, selection_end_y;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400474 int selection_start_row, selection_start_col;
475 int selection_end_row, selection_end_col;
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -0400476 struct wl_list link;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500477};
478
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000479/* Create default tab stops, every 8 characters */
480static void
481terminal_init_tabs(struct terminal *terminal)
482{
483 int i = 0;
484
485 while (i < terminal->width) {
486 if (i % 8 == 0)
487 terminal->tab_ruler[i] = 1;
488 else
489 terminal->tab_ruler[i] = 0;
490 i++;
491 }
492}
493
Callum Lowcay30eeae52011-01-07 19:46:55 +0000494static void
495terminal_init(struct terminal *terminal)
496{
497 terminal->curr_attr = terminal->color_scheme->default_attr;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000498 terminal->origin_mode = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000499 terminal->mode = MODE_SHOW_CURSOR |
500 MODE_AUTOREPEAT |
Callum Lowcay7e08e902011-01-07 19:47:02 +0000501 MODE_ALT_SENDS_ESC |
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000502 MODE_AUTOWRAP;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000503
504 terminal->row = 0;
505 terminal->column = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000506
Callum Lowcay256e72f2011-01-07 19:47:01 +0000507 terminal->g0 = CS_US;
508 terminal->g1 = CS_US;
509 terminal->cs = terminal->g0;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000510 terminal->key_mode = KM_NORMAL;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000511
512 terminal->saved_g0 = terminal->g0;
513 terminal->saved_g1 = terminal->g1;
514 terminal->saved_cs = terminal->cs;
515
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000516 terminal->saved_attr = terminal->curr_attr;
517 terminal->saved_origin_mode = terminal->origin_mode;
518 terminal->saved_row = terminal->row;
519 terminal->saved_column = terminal->column;
520
521 if (terminal->tab_ruler != NULL) terminal_init_tabs(terminal);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000522}
523
524static void
525init_color_table(struct terminal *terminal)
526{
527 int c, r;
528 struct terminal_color *color_table = terminal->color_table;
529
530 for (c = 0; c < 256; c ++) {
531 if (c < 16) {
532 color_table[c] = terminal->color_scheme->palette[c];
533 } else if (c < 232) {
534 r = c - 16;
535 color_table[c].b = ((double)(r % 6) / 6.0); r /= 6;
536 color_table[c].g = ((double)(r % 6) / 6.0); r /= 6;
537 color_table[c].r = ((double)(r % 6) / 6.0);
538 color_table[c].a = 1.0;
539 } else {
540 r = (c - 232) * 10 + 8;
541 color_table[c].r = ((double) r) / 256.0;
542 color_table[c].g = color_table[c].r;
543 color_table[c].b = color_table[c].r;
544 color_table[c].a = 1.0;
545 }
546 }
547}
548
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000549static union utf8_char *
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500550terminal_get_row(struct terminal *terminal, int row)
551{
552 int index;
553
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700554 index = (row + terminal->start) & (terminal->buffer_height - 1);
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500555
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700556 return (void *) terminal->data + index * terminal->data_pitch;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500557}
558
Callum Lowcay30eeae52011-01-07 19:46:55 +0000559static struct attr*
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500560terminal_get_attr_row(struct terminal *terminal, int row)
561{
Callum Lowcay30eeae52011-01-07 19:46:55 +0000562 int index;
563
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700564 index = (row + terminal->start) & (terminal->buffer_height - 1);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000565
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700566 return (void *) terminal->data_attr + index * terminal->attr_pitch;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000567}
568
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500569union decoded_attr {
Callum Lowcay9d708b02011-01-12 20:06:17 +1300570 struct attr attr;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500571 uint32_t key;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500572};
573
574static void
575terminal_decode_attr(struct terminal *terminal, int row, int col,
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500576 union decoded_attr *decoded)
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500577{
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500578 struct attr attr;
579 int foreground, background, tmp;
Kristian Høgsberg59826582011-01-20 11:56:57 -0500580
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500581 decoded->attr.s = 0;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -0400582 if (((row == terminal->selection_start_row &&
583 col >= terminal->selection_start_col) ||
584 row > terminal->selection_start_row) &&
585 ((row == terminal->selection_end_row &&
586 col < terminal->selection_end_col) ||
587 row < terminal->selection_end_row))
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500588 decoded->attr.s = 1;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500589
590 /* get the attributes for this character cell */
591 attr = terminal_get_attr_row(terminal, row)[col];
592 if ((attr.a & ATTRMASK_INVERSE) ||
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500593 decoded->attr.s ||
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500594 ((terminal->mode & MODE_SHOW_CURSOR) &&
Kristian Høgsberg86adef92012-08-13 22:25:53 -0400595 window_has_focus(terminal->window) && terminal->row == row &&
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500596 terminal->column == col)) {
597 foreground = attr.bg;
598 background = attr.fg;
599 if (attr.a & ATTRMASK_BOLD) {
600 if (foreground <= 16) foreground |= 0x08;
601 if (background <= 16) background &= 0x07;
602 }
603 } else {
604 foreground = attr.fg;
605 background = attr.bg;
606 }
607
608 if (terminal->mode & MODE_INVERSE) {
609 tmp = foreground;
610 foreground = background;
611 background = tmp;
612 if (attr.a & ATTRMASK_BOLD) {
613 if (foreground <= 16) foreground |= 0x08;
614 if (background <= 16) background &= 0x07;
615 }
616 }
617
Callum Lowcay9d708b02011-01-12 20:06:17 +1300618 decoded->attr.fg = foreground;
619 decoded->attr.bg = background;
620 decoded->attr.a = attr.a;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000621}
622
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500623
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500624static void
Callum Lowcaybbeac602011-01-07 19:46:58 +0000625terminal_scroll_buffer(struct terminal *terminal, int d)
626{
627 int i;
628
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700629 terminal->start += d;
630 if (d < 0) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000631 d = 0 - d;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700632 for (i = 0; i < d; i++) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000633 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
634 attr_init(terminal_get_attr_row(terminal, i),
635 terminal->curr_attr, terminal->width);
636 }
637 } else {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700638 for (i = terminal->height - d; i < terminal->height; i++) {
Callum Lowcaybbeac602011-01-07 19:46:58 +0000639 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
640 attr_init(terminal_get_attr_row(terminal, i),
641 terminal->curr_attr, terminal->width);
642 }
643 }
Kristian Høgsberg18e928d2012-06-27 19:29:41 -0400644
645 terminal->selection_start_row -= d;
646 terminal->selection_end_row -= d;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000647}
648
649static void
650terminal_scroll_window(struct terminal *terminal, int d)
651{
652 int i;
653 int window_height;
654 int from_row, to_row;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000655
656 // scrolling range is inclusive
657 window_height = terminal->margin_bottom - terminal->margin_top + 1;
658 d = d % (window_height + 1);
659 if(d < 0) {
660 d = 0 - d;
661 to_row = terminal->margin_bottom;
662 from_row = terminal->margin_bottom - d;
663
664 for (i = 0; i < (window_height - d); i++) {
665 memcpy(terminal_get_row(terminal, to_row - i),
666 terminal_get_row(terminal, from_row - i),
667 terminal->data_pitch);
668 memcpy(terminal_get_attr_row(terminal, to_row - i),
669 terminal_get_attr_row(terminal, from_row - i),
670 terminal->attr_pitch);
671 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000672 for (i = terminal->margin_top; i < (terminal->margin_top + d); i++) {
673 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000674 attr_init(terminal_get_attr_row(terminal, i),
675 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000676 }
677 } else {
678 to_row = terminal->margin_top;
679 from_row = terminal->margin_top + d;
680
681 for (i = 0; i < (window_height - d); i++) {
682 memcpy(terminal_get_row(terminal, to_row + i),
683 terminal_get_row(terminal, from_row + i),
684 terminal->data_pitch);
685 memcpy(terminal_get_attr_row(terminal, to_row + i),
686 terminal_get_attr_row(terminal, from_row + i),
687 terminal->attr_pitch);
688 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000689 for (i = terminal->margin_bottom - d + 1; i <= terminal->margin_bottom; i++) {
690 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000691 attr_init(terminal_get_attr_row(terminal, i),
692 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000693 }
694 }
695}
696
697static void
698terminal_scroll(struct terminal *terminal, int d)
699{
700 if(terminal->margin_top == 0 && terminal->margin_bottom == terminal->height - 1)
701 terminal_scroll_buffer(terminal, d);
702 else
703 terminal_scroll_window(terminal, d);
704}
705
706static void
Callum Lowcay69e96582011-01-07 19:47:00 +0000707terminal_shift_line(struct terminal *terminal, int d)
708{
709 union utf8_char *row;
Kristian Høgsberg00439612011-01-25 15:16:01 -0500710 struct attr *attr_row;
Callum Lowcay69e96582011-01-07 19:47:00 +0000711
712 row = terminal_get_row(terminal, terminal->row);
713 attr_row = terminal_get_attr_row(terminal, terminal->row);
714
715 if ((terminal->width + d) <= terminal->column)
716 d = terminal->column + 1 - terminal->width;
717 if ((terminal->column + d) >= terminal->width)
718 d = terminal->width - terminal->column - 1;
719
720 if (d < 0) {
721 d = 0 - d;
722 memmove(&row[terminal->column],
723 &row[terminal->column + d],
724 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
Callum Lowcay69e96582011-01-07 19:47:00 +0000725 memmove(&attr_row[terminal->column], &attr_row[terminal->column + d],
726 (terminal->width - terminal->column - d) * sizeof(struct attr));
727 memset(&row[terminal->width - d], 0, d * sizeof(union utf8_char));
728 attr_init(&attr_row[terminal->width - d], terminal->curr_attr, d);
729 } else {
730 memmove(&row[terminal->column + d], &row[terminal->column],
731 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
732 memmove(&attr_row[terminal->column + d], &attr_row[terminal->column],
733 (terminal->width - terminal->column - d) * sizeof(struct attr));
734 memset(&row[terminal->column], 0, d * sizeof(union utf8_char));
735 attr_init(&attr_row[terminal->column], terminal->curr_attr, d);
736 }
737}
738
739static void
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700740terminal_resize_cells(struct terminal *terminal,
741 int width, int height)
Kristian Høgsberg22106762008-12-08 13:50:07 -0500742{
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000743 union utf8_char *data;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000744 struct attr *data_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000745 char *tab_ruler;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000746 int data_pitch, attr_pitch;
Kristian Høgsberg00439612011-01-25 15:16:01 -0500747 int i, l, total_rows;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700748 uint32_t d, uheight = height;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500749 struct rectangle allocation;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000750 struct winsize ws;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500751
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700752 if (uheight > terminal->buffer_height)
753 height = terminal->buffer_height;
754
Kristian Høgsberg22106762008-12-08 13:50:07 -0500755 if (terminal->width == width && terminal->height == height)
756 return;
757
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700758 if (terminal->data && width <= terminal->max_width) {
759 d = 0;
760 if (height < terminal->height && height <= terminal->row)
761 d = terminal->height - height;
762 else if (height > terminal->height &&
763 terminal->height - 1 == terminal->row) {
764 d = terminal->height - height;
765 if (terminal->log_size < uheight)
766 d = -terminal->start;
767 }
Kristian Høgsberg22106762008-12-08 13:50:07 -0500768
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700769 terminal->start += d;
770 terminal->row -= d;
771 } else {
772 terminal->max_width = width;
773 data_pitch = width * sizeof(union utf8_char);
774 data = zalloc(data_pitch * terminal->buffer_height);
775 attr_pitch = width * sizeof(struct attr);
776 data_attr = malloc(attr_pitch * terminal->buffer_height);
777 tab_ruler = zalloc(width);
778 attr_init(data_attr, terminal->curr_attr,
779 width * terminal->buffer_height);
780
781 if (terminal->data && terminal->data_attr) {
782 if (width > terminal->width)
783 l = terminal->width;
784 else
785 l = width;
786
787 if (terminal->height > height) {
788 total_rows = height;
789 i = 1 + terminal->row - height;
790 if (i > 0) {
791 terminal->start += i;
792 terminal->row = terminal->row - i;
793 }
794 } else {
795 total_rows = terminal->height;
José Bollo4a4704a2013-09-13 11:28:51 +0200796 }
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700797
798 for (i = 0; i < total_rows; i++) {
799 memcpy(&data[width * i],
800 terminal_get_row(terminal, i),
801 l * sizeof(union utf8_char));
802 memcpy(&data_attr[width * i],
803 terminal_get_attr_row(terminal, i),
804 l * sizeof(struct attr));
805 }
806
807 free(terminal->data);
808 free(terminal->data_attr);
809 free(terminal->tab_ruler);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500810 }
811
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700812 terminal->data_pitch = data_pitch;
813 terminal->attr_pitch = attr_pitch;
814 terminal->data = data;
815 terminal->data_attr = data_attr;
816 terminal->tab_ruler = tab_ruler;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -0700817 terminal->start = 0;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500818 }
819
Callum Lowcay86653ed2011-01-07 19:47:03 +0000820 terminal->margin_bottom =
821 height - (terminal->height - terminal->margin_bottom);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500822 terminal->width = width;
823 terminal->height = height;
Kristian Høgsbergdcfff552013-11-22 22:43:20 -0800824 terminal_init_tabs(terminal);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500825
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000826 /* Update the window size */
827 ws.ws_row = terminal->height;
828 ws.ws_col = terminal->width;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500829 widget_get_allocation(terminal->widget, &allocation);
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500830 ws.ws_xpixel = allocation.width;
831 ws.ws_ypixel = allocation.height;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000832 ioctl(terminal->master, TIOCSWINSZ, &ws);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500833}
834
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500835static void
836resize_handler(struct widget *widget,
837 int32_t width, int32_t height, void *data)
838{
839 struct terminal *terminal = data;
840 int32_t columns, rows, m;
Kristian Høgsberga83be202013-10-23 20:47:35 -0700841 char *p;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500842 m = 2 * terminal->margin;
Peng Wuf291f202013-06-06 15:32:41 +0800843 columns = (width - m) / (int32_t) terminal->average_width;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500844 rows = (height - m) / (int32_t) terminal->extents.height;
845
Kristian Høgsbergb36f7ef2012-10-10 11:41:21 -0400846 if (!window_is_fullscreen(terminal->window) &&
847 !window_is_maximized(terminal->window)) {
Peng Wuf291f202013-06-06 15:32:41 +0800848 width = columns * terminal->average_width + m;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500849 height = rows * terminal->extents.height + m;
850 widget_set_size(terminal->widget, width, height);
Kristian Høgsberga83be202013-10-23 20:47:35 -0700851 asprintf(&p, "%s — [%dx%d]", terminal->title, columns, rows);
852 window_set_title(terminal->window, p);
853 free(p);
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500854 }
855
856 terminal_resize_cells(terminal, columns, rows);
857}
858
859static void
860terminal_resize(struct terminal *terminal, int columns, int rows)
861{
862 int32_t width, height, m;
863
Kristian Høgsbergb36f7ef2012-10-10 11:41:21 -0400864 if (window_is_fullscreen(terminal->window) ||
865 window_is_maximized(terminal->window))
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500866 return;
867
868 m = 2 * terminal->margin;
Peng Wuf291f202013-06-06 15:32:41 +0800869 width = columns * terminal->average_width + m;
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500870 height = rows * terminal->extents.height + m;
Kristian Høgsberga1627922012-06-20 17:30:03 -0400871
Jason Ekstrandee7fefc2013-10-13 19:08:38 -0500872 window_frame_set_child_size(terminal->widget, width, height);
Kristian Høgsbergbb977002012-01-10 19:11:42 -0500873}
874
Callum Lowcay30eeae52011-01-07 19:46:55 +0000875struct color_scheme DEFAULT_COLORS = {
876 {
877 {0, 0, 0, 1}, /* black */
878 {0.66, 0, 0, 1}, /* red */
879 {0 , 0.66, 0, 1}, /* green */
880 {0.66, 0.33, 0, 1}, /* orange (nicer than muddy yellow) */
881 {0 , 0 , 0.66, 1}, /* blue */
882 {0.66, 0 , 0.66, 1}, /* magenta */
883 {0, 0.66, 0.66, 1}, /* cyan */
884 {0.66, 0.66, 0.66, 1}, /* light grey */
885 {0.22, 0.33, 0.33, 1}, /* dark grey */
886 {1, 0.33, 0.33, 1}, /* high red */
887 {0.33, 1, 0.33, 1}, /* high green */
888 {1, 1, 0.33, 1}, /* high yellow */
889 {0.33, 0.33, 1, 1}, /* high blue */
890 {1, 0.33, 1, 1}, /* high magenta */
891 {0.33, 1, 1, 1}, /* high cyan */
892 {1, 1, 1, 1} /* white */
893 },
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500894 0, /* black border */
Callum Lowcay30eeae52011-01-07 19:46:55 +0000895 {7, 0, 0, } /* bg:black (0), fg:light gray (7) */
896};
Kristian Høgsberg12308a42009-09-28 13:08:50 -0400897
Kristian Høgsberg22106762008-12-08 13:50:07 -0500898static void
Kristian Høgsbergf106fd52011-01-11 10:11:39 -0500899terminal_set_color(struct terminal *terminal, cairo_t *cr, int index)
900{
901 cairo_set_source_rgba(cr,
902 terminal->color_table[index].r,
903 terminal->color_table[index].g,
904 terminal->color_table[index].b,
905 terminal->color_table[index].a);
906}
907
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500908static void
909terminal_send_selection(struct terminal *terminal, int fd)
910{
911 int row, col;
912 union utf8_char *p_row;
913 union decoded_attr attr;
914 FILE *fp;
915 int len;
916
917 fp = fdopen(fd, "w");
Brian Lovin1bf14812013-08-08 16:12:55 -0700918 if (fp == NULL){
919 close(fd);
920 return;
921 }
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500922 for (row = 0; row < terminal->height; row++) {
923 p_row = terminal_get_row(terminal, row);
924 for (col = 0; col < terminal->width; col++) {
Peng Wucfcc1112013-08-19 10:59:21 +0800925 if (p_row[col].ch == 0x200B) /* space glyph */
926 continue;
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500927 /* get the attributes for this character cell */
928 terminal_decode_attr(terminal, row, col, &attr);
929 if (!attr.attr.s)
930 continue;
931 len = strnlen((char *) p_row[col].byte, 4);
Kristian Høgsberg0dee6472012-07-01 21:25:41 -0400932 if (len > 0)
933 fwrite(p_row[col].byte, 1, len, fp);
934 if (len == 0 || col == terminal->width - 1) {
935 fwrite("\n", 1, 1, fp);
936 break;
937 }
Kristian Høgsberg31cce052011-01-21 15:18:55 -0500938 }
939 }
940 fclose(fp);
941}
942
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500943struct glyph_run {
944 struct terminal *terminal;
945 cairo_t *cr;
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -0400946 unsigned int count;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500947 union decoded_attr attr;
948 cairo_glyph_t glyphs[256], *g;
949};
950
951static void
952glyph_run_init(struct glyph_run *run, struct terminal *terminal, cairo_t *cr)
953{
954 run->terminal = terminal;
955 run->cr = cr;
956 run->g = run->glyphs;
957 run->count = 0;
958 run->attr.key = 0;
959}
960
961static void
962glyph_run_flush(struct glyph_run *run, union decoded_attr attr)
963{
964 cairo_scaled_font_t *font;
965
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500966 if (run->count > ARRAY_LENGTH(run->glyphs) - 10 ||
967 (attr.key != run->attr.key)) {
Callum Lowcay9d708b02011-01-12 20:06:17 +1300968 if (run->attr.attr.a & (ATTRMASK_BOLD | ATTRMASK_BLINK))
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500969 font = run->terminal->font_bold;
970 else
971 font = run->terminal->font_normal;
972 cairo_set_scaled_font(run->cr, font);
973 terminal_set_color(run->terminal, run->cr,
Callum Lowcay9d708b02011-01-12 20:06:17 +1300974 run->attr.attr.fg);
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500975
Callum Lowcay9d708b02011-01-12 20:06:17 +1300976 if (!(run->attr.attr.a & ATTRMASK_CONCEALED))
977 cairo_show_glyphs (run->cr, run->glyphs, run->count);
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500978 run->g = run->glyphs;
979 run->count = 0;
980 }
Callum Lowcay9d708b02011-01-12 20:06:17 +1300981 run->attr = attr;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500982}
983
984static void
985glyph_run_add(struct glyph_run *run, int x, int y, union utf8_char *c)
986{
987 int num_glyphs;
988 cairo_scaled_font_t *font;
989
990 num_glyphs = ARRAY_LENGTH(run->glyphs) - run->count;
991
Callum Lowcay9d708b02011-01-12 20:06:17 +1300992 if (run->attr.attr.a & (ATTRMASK_BOLD | ATTRMASK_BLINK))
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -0500993 font = run->terminal->font_bold;
994 else
995 font = run->terminal->font_normal;
996
997 cairo_move_to(run->cr, x, y);
998 cairo_scaled_font_text_to_glyphs (font, x, y,
999 (char *) c->byte, 4,
1000 &run->g, &num_glyphs,
1001 NULL, NULL, NULL);
1002 run->g += num_glyphs;
1003 run->count += num_glyphs;
1004}
1005
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001006
Kristian Høgsbergf106fd52011-01-11 10:11:39 -05001007static void
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001008redraw_handler(struct widget *widget, void *data)
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001009{
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05001010 struct terminal *terminal = data;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -05001011 struct rectangle allocation;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001012 cairo_t *cr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001013 int top_margin, side_margin;
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001014 int row, col, cursor_x, cursor_y;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001015 union utf8_char *p_row;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001016 union decoded_attr attr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001017 int text_x, text_y;
Kristian Høgsberg2aac3022009-12-21 10:04:53 -05001018 cairo_surface_t *surface;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001019 double d;
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001020 struct glyph_run run;
Kristian Høgsberg59826582011-01-20 11:56:57 -05001021 cairo_font_extents_t extents;
Peng Wuf291f202013-06-06 15:32:41 +08001022 double average_width;
Peng Wucfcc1112013-08-19 10:59:21 +08001023 double unichar_width;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001024
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001025 surface = window_get_surface(terminal->window);
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001026 widget_get_allocation(terminal->widget, &allocation);
Alexander Larssonde79dd02013-05-22 14:41:34 +02001027 cr = widget_cairo_create(terminal->widget);
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001028 cairo_rectangle(cr, allocation.x, allocation.y,
1029 allocation.width, allocation.height);
1030 cairo_clip(cr);
1031 cairo_push_group(cr);
1032
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001033 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
Kristian Høgsberg71eca892011-01-11 10:13:00 -05001034 terminal_set_color(terminal, cr, terminal->color_scheme->border);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001035 cairo_paint(cr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001036
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05001037 cairo_set_scaled_font(cr, terminal->font_normal);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001038
Kristian Høgsberg59826582011-01-20 11:56:57 -05001039 extents = terminal->extents;
Peng Wuf291f202013-06-06 15:32:41 +08001040 average_width = terminal->average_width;
1041 side_margin = (allocation.width - terminal->width * average_width) / 2;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -05001042 top_margin = (allocation.height - terminal->height * extents.height) / 2;
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001043
Callum Lowcay30eeae52011-01-07 19:46:55 +00001044 cairo_set_line_width(cr, 1.0);
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001045 cairo_translate(cr, allocation.x + side_margin,
1046 allocation.y + top_margin);
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001047 /* paint the background */
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001048 for (row = 0; row < terminal->height; row++) {
Peng Wucfcc1112013-08-19 10:59:21 +08001049 p_row = terminal_get_row(terminal, row);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001050 for (col = 0; col < terminal->width; col++) {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001051 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -05001052 terminal_decode_attr(terminal, row, col, &attr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001053
Callum Lowcay9d708b02011-01-12 20:06:17 +13001054 if (attr.attr.bg == terminal->color_scheme->border)
Kristian Høgsbergfb266a32011-01-11 10:15:21 -05001055 continue;
1056
Peng Wucfcc1112013-08-19 10:59:21 +08001057 if (is_wide(p_row[col]))
1058 unichar_width = 2 * average_width;
1059 else
1060 unichar_width = average_width;
1061
Callum Lowcay9d708b02011-01-12 20:06:17 +13001062 terminal_set_color(terminal, cr, attr.attr.bg);
Peng Wuf291f202013-06-06 15:32:41 +08001063 cairo_move_to(cr, col * average_width,
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001064 row * extents.height);
Peng Wucfcc1112013-08-19 10:59:21 +08001065 cairo_rel_line_to(cr, unichar_width, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001066 cairo_rel_line_to(cr, 0, extents.height);
Peng Wucfcc1112013-08-19 10:59:21 +08001067 cairo_rel_line_to(cr, -unichar_width, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001068 cairo_close_path(cr);
1069 cairo_fill(cr);
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001070 }
1071 }
Callum Lowcay30eeae52011-01-07 19:46:55 +00001072
Kristian Høgsberg8c254202010-12-25 08:58:46 -05001073 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
1074
1075 /* paint the foreground */
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001076 glyph_run_init(&run, terminal, cr);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001077 for (row = 0; row < terminal->height; row++) {
1078 p_row = terminal_get_row(terminal, row);
1079 for (col = 0; col < terminal->width; col++) {
1080 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -05001081 terminal_decode_attr(terminal, row, col, &attr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001082
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001083 glyph_run_flush(&run, attr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001084
Peng Wuf291f202013-06-06 15:32:41 +08001085 text_x = col * average_width;
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001086 text_y = extents.ascent + row * extents.height;
Callum Lowcay9d708b02011-01-12 20:06:17 +13001087 if (attr.attr.a & ATTRMASK_UNDERLINE) {
1088 terminal_set_color(terminal, cr, attr.attr.fg);
Callum Lowcay86653ed2011-01-07 19:47:03 +00001089 cairo_move_to(cr, text_x, (double)text_y + 1.5);
Peng Wuf291f202013-06-06 15:32:41 +08001090 cairo_line_to(cr, text_x + average_width, (double) text_y + 1.5);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001091 cairo_stroke(cr);
1092 }
Kristian Høgsberg4f506702010-12-25 16:14:23 -05001093
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001094 glyph_run_add(&run, text_x, text_y, &p_row[col]);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001095 }
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001096 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -05001097
Kristian Høgsberg1d3e9392011-01-11 11:06:49 -05001098 attr.key = ~0;
1099 glyph_run_flush(&run, attr);
1100
Kristian Høgsberg86adef92012-08-13 22:25:53 -04001101 if ((terminal->mode & MODE_SHOW_CURSOR) &&
1102 !window_has_focus(terminal->window)) {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001103 d = 0.5;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001104
Callum Lowcay30eeae52011-01-07 19:46:55 +00001105 cairo_set_line_width(cr, 1);
Peng Wuf291f202013-06-06 15:32:41 +08001106 cairo_move_to(cr, terminal->column * average_width + d,
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001107 terminal->row * extents.height + d);
Peng Wuf291f202013-06-06 15:32:41 +08001108 cairo_rel_line_to(cr, average_width - 2 * d, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001109 cairo_rel_line_to(cr, 0, extents.height - 2 * d);
Peng Wuf291f202013-06-06 15:32:41 +08001110 cairo_rel_line_to(cr, -average_width + 2 * d, 0);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001111 cairo_close_path(cr);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001112
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001113 cairo_stroke(cr);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001114 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -05001115
Kristian Høgsbergf39a9cc2011-01-20 12:37:33 -05001116 cairo_pop_group_to_source(cr);
1117 cairo_paint(cr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001118 cairo_destroy(cr);
Kristian Høgsberg2aac3022009-12-21 10:04:53 -05001119 cairo_surface_destroy(surface);
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001120
1121 if (terminal->send_cursor_position) {
1122 cursor_x = side_margin + allocation.x +
Peng Wuf291f202013-06-06 15:32:41 +08001123 terminal->column * average_width;
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001124 cursor_y = top_margin + allocation.y +
1125 terminal->row * extents.height;
1126 window_set_text_cursor_position(terminal->window,
1127 cursor_x, cursor_y);
1128 terminal->send_cursor_position = 0;
1129 }
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001130}
1131
1132static void
Kristian Høgsberg26130862011-08-24 11:30:21 -04001133terminal_write(struct terminal *terminal, const char *data, size_t length)
1134{
1135 if (write(terminal->master, data, length) < 0)
1136 abort();
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001137 terminal->send_cursor_position = 1;
Kristian Høgsberg26130862011-08-24 11:30:21 -04001138}
1139
1140static void
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001141terminal_data(struct terminal *terminal, const char *data, size_t length);
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05001142
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001143static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001144handle_char(struct terminal *terminal, union utf8_char utf8);
1145
1146static void
Callum Lowcay30eeae52011-01-07 19:46:55 +00001147handle_sgr(struct terminal *terminal, int code);
1148
1149static void
Callum Lowcaybbeac602011-01-07 19:46:58 +00001150handle_term_parameter(struct terminal *terminal, int code, int sr)
1151{
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001152 int i;
1153
Callum Lowcay67a201d2011-01-12 19:23:41 +13001154 if (terminal->escape_flags & ESC_FLAG_WHAT) {
Callum Lowcaybbeac602011-01-07 19:46:58 +00001155 switch(code) {
Callum Lowcay7e08e902011-01-07 19:47:02 +00001156 case 1: /* DECCKM */
1157 if (sr) terminal->key_mode = KM_APPLICATION;
1158 else terminal->key_mode = KM_NORMAL;
1159 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001160 case 2: /* DECANM */
1161 /* No VT52 support yet */
1162 terminal->g0 = CS_US;
1163 terminal->g1 = CS_US;
1164 terminal->cs = terminal->g0;
1165 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001166 case 3: /* DECCOLM */
1167 if (sr)
1168 terminal_resize(terminal, 132, 24);
1169 else
1170 terminal_resize(terminal, 80, 24);
1171
1172 /* set columns, but also home cursor and clear screen */
1173 terminal->row = 0; terminal->column = 0;
1174 for (i = 0; i < terminal->height; i++) {
1175 memset(terminal_get_row(terminal, i),
1176 0, terminal->data_pitch);
1177 attr_init(terminal_get_attr_row(terminal, i),
1178 terminal->curr_attr, terminal->width);
1179 }
1180 break;
1181 case 5: /* DECSCNM */
1182 if (sr) terminal->mode |= MODE_INVERSE;
1183 else terminal->mode &= ~MODE_INVERSE;
1184 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001185 case 6: /* DECOM */
1186 terminal->origin_mode = sr;
1187 if (terminal->origin_mode)
1188 terminal->row = terminal->margin_top;
1189 else
1190 terminal->row = 0;
1191 terminal->column = 0;
1192 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001193 case 7: /* DECAWM */
1194 if (sr) terminal->mode |= MODE_AUTOWRAP;
1195 else terminal->mode &= ~MODE_AUTOWRAP;
1196 break;
1197 case 8: /* DECARM */
1198 if (sr) terminal->mode |= MODE_AUTOREPEAT;
1199 else terminal->mode &= ~MODE_AUTOREPEAT;
1200 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001201 case 12: /* Very visible cursor (CVVIS) */
1202 /* FIXME: What do we do here. */
1203 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001204 case 25:
1205 if (sr) terminal->mode |= MODE_SHOW_CURSOR;
1206 else terminal->mode &= ~MODE_SHOW_CURSOR;
1207 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001208 case 1034: /* smm/rmm, meta mode on/off */
1209 /* ignore */
1210 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001211 case 1037: /* deleteSendsDel */
1212 if (sr) terminal->mode |= MODE_DELETE_SENDS_DEL;
1213 else terminal->mode &= ~MODE_DELETE_SENDS_DEL;
1214 break;
1215 case 1039: /* altSendsEscape */
1216 if (sr) terminal->mode |= MODE_ALT_SENDS_ESC;
1217 else terminal->mode &= ~MODE_ALT_SENDS_ESC;
1218 break;
Kristian Høgsberge828e902012-06-20 16:59:17 -04001219 case 1049: /* rmcup/smcup, alternate screen */
1220 /* Ignore. Should be possible to implement,
1221 * but it's kind of annoying. */
1222 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001223 default:
1224 fprintf(stderr, "Unknown parameter: ?%d\n", code);
1225 break;
1226 }
1227 } else {
1228 switch(code) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001229 case 4: /* IRM */
1230 if (sr) terminal->mode |= MODE_IRM;
1231 else terminal->mode &= ~MODE_IRM;
1232 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001233 case 20: /* LNM */
1234 if (sr) terminal->mode |= MODE_LF_NEWLINE;
1235 else terminal->mode &= ~MODE_LF_NEWLINE;
1236 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001237 default:
1238 fprintf(stderr, "Unknown parameter: %d\n", code);
1239 break;
1240 }
1241 }
1242}
1243
1244static void
Callum Lowcay67a201d2011-01-12 19:23:41 +13001245handle_dcs(struct terminal *terminal)
1246{
1247}
1248
1249static void
1250handle_osc(struct terminal *terminal)
1251{
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001252 char *p;
1253 int code;
1254
1255 terminal->escape[terminal->escape_length++] = '\0';
1256 p = &terminal->escape[2];
1257 code = strtol(p, &p, 10);
1258 if (*p == ';') p++;
1259
1260 switch (code) {
1261 case 0: /* Icon name and window title */
1262 case 1: /* Icon label */
1263 case 2: /* Window title*/
Kristian Høgsberga83be202013-10-23 20:47:35 -07001264 free(terminal->title);
1265 terminal->title = strdup(p);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001266 window_set_title(terminal->window, p);
1267 break;
Kristian Høgsberg8a205002013-09-11 11:52:56 -07001268 case 7: /* shell cwd as uri */
1269 break;
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001270 default:
Kristian Høgsberg8a205002013-09-11 11:52:56 -07001271 fprintf(stderr, "Unknown OSC escape code %d, text %s\n",
1272 code, p);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001273 break;
1274 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13001275}
1276
1277static void
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001278handle_escape(struct terminal *terminal)
1279{
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001280 union utf8_char *row;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001281 struct attr *attr_row;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001282 char *p;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001283 int i, count, x, y, top, bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001284 int args[10], set[10] = { 0, };
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001285 char response[MAX_RESPONSE] = {0, };
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001286 struct rectangle allocation;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001287
1288 terminal->escape[terminal->escape_length++] = '\0';
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001289 i = 0;
1290 p = &terminal->escape[2];
1291 while ((isdigit(*p) || *p == ';') && i < 10) {
1292 if (*p == ';') {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001293 if (!set[i]) {
1294 args[i] = 0;
1295 set[i] = 1;
1296 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001297 p++;
1298 i++;
1299 } else {
1300 args[i] = strtol(p, &p, 10);
1301 set[i] = 1;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001302 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001303 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001304
1305 switch (*p) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001306 case '@': /* ICH */
1307 count = set[0] ? args[0] : 1;
1308 if (count == 0) count = 1;
1309 terminal_shift_line(terminal, count);
1310 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001311 case 'A': /* CUU */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001312 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001313 if (count == 0) count = 1;
1314 if (terminal->row - count >= terminal->margin_top)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001315 terminal->row -= count;
1316 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001317 terminal->row = terminal->margin_top;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001318 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001319 case 'B': /* CUD */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001320 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001321 if (count == 0) count = 1;
1322 if (terminal->row + count <= terminal->margin_bottom)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001323 terminal->row += count;
1324 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001325 terminal->row = terminal->margin_bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001326 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001327 case 'C': /* CUF */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001328 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001329 if (count == 0) count = 1;
1330 if ((terminal->column + count) < terminal->width)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001331 terminal->column += count;
1332 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001333 terminal->column = terminal->width - 1;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001334 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001335 case 'D': /* CUB */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001336 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001337 if (count == 0) count = 1;
1338 if ((terminal->column - count) >= 0)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001339 terminal->column -= count;
1340 else
1341 terminal->column = 0;
1342 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001343 case 'E': /* CNL */
1344 count = set[0] ? args[0] : 1;
1345 if (terminal->row + count <= terminal->margin_bottom)
1346 terminal->row += count;
1347 else
1348 terminal->row = terminal->margin_bottom;
1349 terminal->column = 0;
1350 break;
1351 case 'F': /* CPL */
1352 count = set[0] ? args[0] : 1;
1353 if (terminal->row - count >= terminal->margin_top)
1354 terminal->row -= count;
1355 else
1356 terminal->row = terminal->margin_top;
1357 terminal->column = 0;
1358 break;
1359 case 'G': /* CHA */
1360 y = set[0] ? args[0] : 1;
1361 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1362
1363 terminal->column = y - 1;
1364 break;
1365 case 'f': /* HVP */
1366 case 'H': /* CUP */
1367 x = (set[1] ? args[1] : 1) - 1;
1368 x = x < 0 ? 0 :
1369 (x >= terminal->width ? terminal->width - 1 : x);
1370
1371 y = (set[0] ? args[0] : 1) - 1;
1372 if (terminal->origin_mode) {
1373 y += terminal->margin_top;
1374 y = y < terminal->margin_top ? terminal->margin_top :
1375 (y > terminal->margin_bottom ? terminal->margin_bottom : y);
1376 } else {
1377 y = y < 0 ? 0 :
1378 (y >= terminal->height ? terminal->height - 1 : y);
1379 }
1380
1381 terminal->row = y;
1382 terminal->column = x;
1383 break;
1384 case 'I': /* CHT */
1385 count = set[0] ? args[0] : 1;
1386 if (count == 0) count = 1;
1387 while (count > 0 && terminal->column < terminal->width) {
1388 if (terminal->tab_ruler[terminal->column]) count--;
1389 terminal->column++;
1390 }
1391 terminal->column--;
1392 break;
1393 case 'J': /* ED */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001394 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001395 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001396 if (!set[0] || args[0] == 0 || args[0] > 2) {
1397 memset(&row[terminal->column],
1398 0, (terminal->width - terminal->column) * sizeof(union utf8_char));
1399 attr_init(&attr_row[terminal->column],
1400 terminal->curr_attr, terminal->width - terminal->column);
1401 for (i = terminal->row + 1; i < terminal->height; i++) {
1402 memset(terminal_get_row(terminal, i),
1403 0, terminal->data_pitch);
1404 attr_init(terminal_get_attr_row(terminal, i),
1405 terminal->curr_attr, terminal->width);
1406 }
1407 } else if (args[0] == 1) {
1408 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1409 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1410 for (i = 0; i < terminal->row; i++) {
1411 memset(terminal_get_row(terminal, i),
1412 0, terminal->data_pitch);
1413 attr_init(terminal_get_attr_row(terminal, i),
1414 terminal->curr_attr, terminal->width);
1415 }
1416 } else if (args[0] == 2) {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07001417 /* Clear screen by scrolling contents out */
1418 terminal_scroll_buffer(terminal,
1419 terminal->end - terminal->start);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001420 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001421 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001422 case 'K': /* EL */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001423 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001424 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001425 if (!set[0] || args[0] == 0 || args[0] > 2) {
1426 memset(&row[terminal->column], 0,
1427 (terminal->width - terminal->column) * sizeof(union utf8_char));
1428 attr_init(&attr_row[terminal->column], terminal->curr_attr,
1429 terminal->width - terminal->column);
1430 } else if (args[0] == 1) {
1431 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1432 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1433 } else if (args[0] == 2) {
1434 memset(row, 0, terminal->data_pitch);
1435 attr_init(attr_row, terminal->curr_attr, terminal->width);
1436 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001437 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001438 case 'L': /* IL */
1439 count = set[0] ? args[0] : 1;
1440 if (count == 0) count = 1;
1441 if (terminal->row >= terminal->margin_top &&
1442 terminal->row < terminal->margin_bottom)
1443 {
1444 top = terminal->margin_top;
1445 terminal->margin_top = terminal->row;
1446 terminal_scroll(terminal, 0 - count);
1447 terminal->margin_top = top;
1448 } else if (terminal->row == terminal->margin_bottom) {
1449 memset(terminal_get_row(terminal, terminal->row),
1450 0, terminal->data_pitch);
1451 attr_init(terminal_get_attr_row(terminal, terminal->row),
1452 terminal->curr_attr, terminal->width);
1453 }
1454 break;
1455 case 'M': /* DL */
1456 count = set[0] ? args[0] : 1;
1457 if (count == 0) count = 1;
1458 if (terminal->row >= terminal->margin_top &&
1459 terminal->row < terminal->margin_bottom)
1460 {
1461 top = terminal->margin_top;
1462 terminal->margin_top = terminal->row;
1463 terminal_scroll(terminal, count);
1464 terminal->margin_top = top;
1465 } else if (terminal->row == terminal->margin_bottom) {
1466 memset(terminal_get_row(terminal, terminal->row),
1467 0, terminal->data_pitch);
1468 }
1469 break;
1470 case 'P': /* DCH */
1471 count = set[0] ? args[0] : 1;
1472 if (count == 0) count = 1;
1473 terminal_shift_line(terminal, 0 - count);
1474 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001475 case 'S': /* SU */
1476 terminal_scroll(terminal, set[0] ? args[0] : 1);
1477 break;
1478 case 'T': /* SD */
1479 terminal_scroll(terminal, 0 - (set[0] ? args[0] : 1));
1480 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001481 case 'X': /* ECH */
1482 count = set[0] ? args[0] : 1;
1483 if (count == 0) count = 1;
1484 if ((terminal->column + count) > terminal->width)
1485 count = terminal->width - terminal->column;
1486 row = terminal_get_row(terminal, terminal->row);
1487 attr_row = terminal_get_attr_row(terminal, terminal->row);
1488 memset(&row[terminal->column], 0, count * sizeof(union utf8_char));
1489 attr_init(&attr_row[terminal->column], terminal->curr_attr, count);
1490 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001491 case 'Z': /* CBT */
1492 count = set[0] ? args[0] : 1;
1493 if (count == 0) count = 1;
1494 while (count > 0 && terminal->column >= 0) {
1495 if (terminal->tab_ruler[terminal->column]) count--;
1496 terminal->column--;
1497 }
1498 terminal->column++;
1499 break;
1500 case '`': /* HPA */
1501 y = set[0] ? args[0] : 1;
1502 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1503
1504 terminal->column = y - 1;
1505 break;
1506 case 'b': /* REP */
1507 count = set[0] ? args[0] : 1;
1508 if (count == 0) count = 1;
1509 if (terminal->last_char.byte[0])
1510 for (i = 0; i < count; i++)
1511 handle_char(terminal, terminal->last_char);
1512 terminal->last_char.byte[0] = 0;
1513 break;
1514 case 'c': /* Primary DA */
Kristian Høgsberg26130862011-08-24 11:30:21 -04001515 terminal_write(terminal, "\e[?6c", 5);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001516 break;
1517 case 'd': /* VPA */
1518 x = set[0] ? args[0] : 1;
1519 x = x <= 0 ? 1 : x > terminal->height ? terminal->height : x;
1520
1521 terminal->row = x - 1;
1522 break;
1523 case 'g': /* TBC */
1524 if (!set[0] || args[0] == 0) {
1525 terminal->tab_ruler[terminal->column] = 0;
1526 } else if (args[0] == 3) {
1527 memset(terminal->tab_ruler, 0, terminal->width);
1528 }
1529 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001530 case 'h': /* SM */
1531 for(i = 0; i < 10 && set[i]; i++) {
1532 handle_term_parameter(terminal, args[i], 1);
1533 }
1534 break;
1535 case 'l': /* RM */
1536 for(i = 0; i < 10 && set[i]; i++) {
1537 handle_term_parameter(terminal, args[i], 0);
1538 }
1539 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001540 case 'm': /* SGR */
Callum Lowcay30eeae52011-01-07 19:46:55 +00001541 for(i = 0; i < 10; i++) {
Callum Lowcay81179db2011-01-10 12:14:01 +13001542 if (i <= 7 && set[i] && set[i + 1] &&
1543 set[i + 2] && args[i + 1] == 5)
1544 {
1545 if (args[i] == 38) {
1546 handle_sgr(terminal, args[i + 2] + 256);
1547 break;
1548 } else if (args[i] == 48) {
1549 handle_sgr(terminal, args[i + 2] + 512);
1550 break;
1551 }
1552 }
Callum Lowcay30eeae52011-01-07 19:46:55 +00001553 if(set[i]) {
1554 handle_sgr(terminal, args[i]);
1555 } else if(i == 0) {
1556 handle_sgr(terminal, 0);
1557 break;
1558 } else {
1559 break;
1560 }
1561 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001562 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001563 case 'n': /* DSR */
1564 i = set[0] ? args[0] : 0;
1565 if (i == 0 || i == 5) {
Kristian Høgsberg26130862011-08-24 11:30:21 -04001566 terminal_write(terminal, "\e[0n", 4);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001567 } else if (i == 6) {
1568 snprintf(response, MAX_RESPONSE, "\e[%d;%dR",
1569 terminal->origin_mode ?
1570 terminal->row+terminal->margin_top : terminal->row+1,
1571 terminal->column+1);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001572 terminal_write(terminal, response, strlen(response));
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001573 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001574 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001575 case 'r':
1576 if(!set[0]) {
1577 terminal->margin_top = 0;
1578 terminal->margin_bottom = terminal->height-1;
1579 terminal->row = 0;
1580 terminal->column = 0;
1581 } else {
1582 top = (set[0] ? args[0] : 1) - 1;
1583 top = top < 0 ? 0 :
1584 (top >= terminal->height ? terminal->height - 1 : top);
1585 bottom = (set[1] ? args[1] : 1) - 1;
1586 bottom = bottom < 0 ? 0 :
1587 (bottom >= terminal->height ? terminal->height - 1 : bottom);
1588 if(bottom > top) {
1589 terminal->margin_top = top;
1590 terminal->margin_bottom = bottom;
1591 } else {
1592 terminal->margin_top = 0;
1593 terminal->margin_bottom = terminal->height-1;
1594 }
1595 if(terminal->origin_mode)
1596 terminal->row = terminal->margin_top;
1597 else
1598 terminal->row = 0;
1599 terminal->column = 0;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001600 }
1601 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001602 case 's':
1603 terminal->saved_row = terminal->row;
1604 terminal->saved_column = terminal->column;
1605 break;
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001606 case 't': /* windowOps */
1607 if (!set[0]) break;
1608 switch (args[0]) {
1609 case 4: /* resize px */
1610 if (set[1] && set[2]) {
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001611 widget_schedule_resize(terminal->widget,
1612 args[2], args[1]);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001613 }
1614 break;
1615 case 8: /* resize ch */
1616 if (set[1] && set[2]) {
1617 terminal_resize(terminal, args[2], args[1]);
1618 }
1619 break;
1620 case 13: /* report position */
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001621 widget_get_allocation(terminal->widget, &allocation);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001622 snprintf(response, MAX_RESPONSE, "\e[3;%d;%dt",
1623 allocation.x, allocation.y);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001624 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001625 break;
1626 case 14: /* report px */
Kristian Høgsbergbb977002012-01-10 19:11:42 -05001627 widget_get_allocation(terminal->widget, &allocation);
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001628 snprintf(response, MAX_RESPONSE, "\e[4;%d;%dt",
1629 allocation.height, allocation.width);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001630 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001631 break;
1632 case 18: /* report ch */
1633 snprintf(response, MAX_RESPONSE, "\e[9;%d;%dt",
1634 terminal->height, terminal->width);
Kristian Høgsberg26130862011-08-24 11:30:21 -04001635 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001636 break;
1637 case 21: /* report title */
1638 snprintf(response, MAX_RESPONSE, "\e]l%s\e\\",
1639 window_get_title(terminal->window));
Kristian Høgsberg26130862011-08-24 11:30:21 -04001640 terminal_write(terminal, response, strlen(response));
Callum Lowcayef57a9b2011-01-14 20:46:23 +13001641 break;
1642 default:
1643 if (args[0] >= 24)
1644 terminal_resize(terminal, terminal->width, args[0]);
1645 else
1646 fprintf(stderr, "Unimplemented windowOp %d\n", args[0]);
1647 break;
1648 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001649 case 'u':
1650 terminal->row = terminal->saved_row;
1651 terminal->column = terminal->saved_column;
1652 break;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001653 default:
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001654 fprintf(stderr, "Unknown CSI escape: %c\n", *p);
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001655 break;
1656 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001657}
1658
1659static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001660handle_non_csi_escape(struct terminal *terminal, char code)
1661{
Callum Lowcaybbeac602011-01-07 19:46:58 +00001662 switch(code) {
1663 case 'M': /* RI */
1664 terminal->row -= 1;
1665 if(terminal->row < terminal->margin_top) {
1666 terminal->row = terminal->margin_top;
1667 terminal_scroll(terminal, -1);
1668 }
1669 break;
1670 case 'E': /* NEL */
1671 terminal->column = 0;
1672 // fallthrough
1673 case 'D': /* IND */
1674 terminal->row += 1;
1675 if(terminal->row > terminal->margin_bottom) {
1676 terminal->row = terminal->margin_bottom;
1677 terminal_scroll(terminal, +1);
1678 }
1679 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001680 case 'c': /* RIS */
1681 terminal_init(terminal);
1682 break;
1683 case 'H': /* HTS */
1684 terminal->tab_ruler[terminal->column] = 1;
1685 break;
1686 case '7': /* DECSC */
1687 terminal->saved_row = terminal->row;
1688 terminal->saved_column = terminal->column;
1689 terminal->saved_attr = terminal->curr_attr;
1690 terminal->saved_origin_mode = terminal->origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001691 terminal->saved_cs = terminal->cs;
1692 terminal->saved_g0 = terminal->g0;
1693 terminal->saved_g1 = terminal->g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001694 break;
1695 case '8': /* DECRC */
1696 terminal->row = terminal->saved_row;
1697 terminal->column = terminal->saved_column;
1698 terminal->curr_attr = terminal->saved_attr;
1699 terminal->origin_mode = terminal->saved_origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001700 terminal->cs = terminal->saved_cs;
1701 terminal->g0 = terminal->saved_g0;
1702 terminal->g1 = terminal->saved_g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001703 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001704 case '=': /* DECPAM */
1705 terminal->key_mode = KM_APPLICATION;
1706 break;
1707 case '>': /* DECPNM */
1708 terminal->key_mode = KM_NORMAL;
1709 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001710 default:
1711 fprintf(stderr, "Unknown escape code: %c\n", code);
1712 break;
1713 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001714}
1715
1716static void
1717handle_special_escape(struct terminal *terminal, char special, char code)
1718{
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001719 int i, numChars;
1720
1721 if (special == '#') {
1722 switch(code) {
1723 case '8':
1724 /* fill with 'E', no cheap way to do this */
1725 memset(terminal->data, 0, terminal->data_pitch * terminal->height);
1726 numChars = terminal->width * terminal->height;
1727 for(i = 0; i < numChars; i++) {
1728 terminal->data[i].byte[0] = 'E';
1729 }
1730 break;
1731 default:
1732 fprintf(stderr, "Unknown HASH escape #%c\n", code);
1733 break;
1734 }
Callum Lowcay256e72f2011-01-07 19:47:01 +00001735 } else if (special == '(' || special == ')') {
1736 switch(code) {
1737 case '0':
1738 if (special == '(')
1739 terminal->g0 = CS_SPECIAL;
1740 else
1741 terminal->g1 = CS_SPECIAL;
1742 break;
1743 case 'A':
1744 if (special == '(')
1745 terminal->g0 = CS_UK;
1746 else
1747 terminal->g1 = CS_UK;
1748 break;
1749 case 'B':
1750 if (special == '(')
1751 terminal->g0 = CS_US;
1752 else
1753 terminal->g1 = CS_US;
1754 break;
1755 default:
1756 fprintf(stderr, "Unknown character set %c\n", code);
1757 break;
1758 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001759 } else {
1760 fprintf(stderr, "Unknown special escape %c%c\n", special, code);
1761 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001762}
1763
1764static void
Callum Lowcay30eeae52011-01-07 19:46:55 +00001765handle_sgr(struct terminal *terminal, int code)
1766{
1767 switch(code) {
1768 case 0:
1769 terminal->curr_attr = terminal->color_scheme->default_attr;
1770 break;
1771 case 1:
1772 terminal->curr_attr.a |= ATTRMASK_BOLD;
1773 if (terminal->curr_attr.fg < 8)
1774 terminal->curr_attr.fg += 8;
1775 break;
1776 case 4:
1777 terminal->curr_attr.a |= ATTRMASK_UNDERLINE;
1778 break;
1779 case 5:
1780 terminal->curr_attr.a |= ATTRMASK_BLINK;
1781 break;
Callum Lowcay81179db2011-01-10 12:14:01 +13001782 case 8:
1783 terminal->curr_attr.a |= ATTRMASK_CONCEALED;
1784 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001785 case 2:
1786 case 21:
1787 case 22:
1788 terminal->curr_attr.a &= ~ATTRMASK_BOLD;
1789 if (terminal->curr_attr.fg < 16 && terminal->curr_attr.fg >= 8)
1790 terminal->curr_attr.fg -= 8;
1791 break;
1792 case 24:
1793 terminal->curr_attr.a &= ~ATTRMASK_UNDERLINE;
1794 break;
1795 case 25:
1796 terminal->curr_attr.a &= ~ATTRMASK_BLINK;
1797 break;
1798 case 7:
1799 case 26:
1800 terminal->curr_attr.a |= ATTRMASK_INVERSE;
1801 break;
1802 case 27:
1803 terminal->curr_attr.a &= ~ATTRMASK_INVERSE;
1804 break;
Callum Lowcay81179db2011-01-10 12:14:01 +13001805 case 28:
1806 terminal->curr_attr.a &= ~ATTRMASK_CONCEALED;
1807 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001808 case 39:
1809 terminal->curr_attr.fg = terminal->color_scheme->default_attr.fg;
1810 break;
1811 case 49:
1812 terminal->curr_attr.bg = terminal->color_scheme->default_attr.bg;
1813 break;
1814 default:
1815 if(code >= 30 && code <= 37) {
1816 terminal->curr_attr.fg = code - 30;
1817 if (terminal->curr_attr.a & ATTRMASK_BOLD)
1818 terminal->curr_attr.fg += 8;
1819 } else if(code >= 40 && code <= 47) {
1820 terminal->curr_attr.bg = code - 40;
Callum Lowcay81179db2011-01-10 12:14:01 +13001821 } else if (code >= 90 && code <= 97) {
1822 terminal->curr_attr.fg = code - 90 + 8;
1823 } else if (code >= 100 && code <= 107) {
1824 terminal->curr_attr.bg = code - 100 + 8;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001825 } else if(code >= 256 && code < 512) {
1826 terminal->curr_attr.fg = code - 256;
1827 } else if(code >= 512 && code < 768) {
1828 terminal->curr_attr.bg = code - 512;
1829 } else {
1830 fprintf(stderr, "Unknown SGR code: %d\n", code);
1831 }
1832 break;
1833 }
1834}
1835
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001836/* Returns 1 if c was special, otherwise 0 */
1837static int
1838handle_special_char(struct terminal *terminal, char c)
1839{
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04001840 union utf8_char *row;
1841 struct attr *attr_row;
1842
1843 row = terminal_get_row(terminal, terminal->row);
1844 attr_row = terminal_get_attr_row(terminal, terminal->row);
1845
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001846 switch(c) {
1847 case '\r':
1848 terminal->column = 0;
1849 break;
1850 case '\n':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001851 if (terminal->mode & MODE_LF_NEWLINE) {
1852 terminal->column = 0;
1853 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001854 /* fallthrough */
1855 case '\v':
1856 case '\f':
Callum Lowcaybbeac602011-01-07 19:46:58 +00001857 terminal->row++;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07001858 if (terminal->row > terminal->margin_bottom) {
Callum Lowcaybbeac602011-01-07 19:46:58 +00001859 terminal->row = terminal->margin_bottom;
1860 terminal_scroll(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001861 }
1862
1863 break;
1864 case '\t':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001865 while (terminal->column < terminal->width) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001866 if (terminal->mode & MODE_IRM)
1867 terminal_shift_line(terminal, +1);
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04001868
1869 if (row[terminal->column].byte[0] == '\0') {
1870 row[terminal->column].byte[0] = ' ';
1871 row[terminal->column].byte[1] = '\0';
1872 attr_row[terminal->column] = terminal->curr_attr;
1873 }
1874
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001875 terminal->column++;
Kristian Høgsbergcca3c2f2012-06-20 15:56:13 -04001876 if (terminal->tab_ruler[terminal->column]) break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001877 }
1878 if (terminal->column >= terminal->width) {
1879 terminal->column = terminal->width - 1;
1880 }
1881
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001882 break;
1883 case '\b':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001884 if (terminal->column >= terminal->width) {
1885 terminal->column = terminal->width - 2;
1886 } else if (terminal->column > 0) {
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001887 terminal->column--;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001888 } else if (terminal->mode & MODE_AUTOWRAP) {
1889 terminal->column = terminal->width - 1;
1890 terminal->row -= 1;
1891 if (terminal->row < terminal->margin_top) {
1892 terminal->row = terminal->margin_top;
1893 terminal_scroll(terminal, -1);
1894 }
1895 }
1896
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001897 break;
1898 case '\a':
1899 /* Bell */
1900 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001901 case '\x0E': /* SO */
1902 terminal->cs = terminal->g1;
1903 break;
1904 case '\x0F': /* SI */
1905 terminal->cs = terminal->g0;
1906 break;
Kristian Høgsberg2a1aa4e2012-08-03 09:37:05 -04001907 case '\0':
1908 break;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001909 default:
1910 return 0;
1911 }
1912
1913 return 1;
1914}
1915
1916static void
1917handle_char(struct terminal *terminal, union utf8_char utf8)
1918{
1919 union utf8_char *row;
1920 struct attr *attr_row;
1921
1922 if (handle_special_char(terminal, utf8.byte[0])) return;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001923
1924 apply_char_set(terminal->cs, &utf8);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001925
1926 /* There are a whole lot of non-characters, control codes,
1927 * and formatting codes that should probably be ignored,
1928 * for example: */
1929 if (strncmp((char*) utf8.byte, "\xEF\xBB\xBF", 3) == 0) {
1930 /* BOM, ignore */
1931 return;
1932 }
1933
1934 /* Some of these non-characters should be translated, e.g.: */
1935 if (utf8.byte[0] < 32) {
1936 utf8.byte[0] = utf8.byte[0] + 64;
1937 }
1938
1939 /* handle right margin effects */
1940 if (terminal->column >= terminal->width) {
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001941 if (terminal->mode & MODE_AUTOWRAP) {
1942 terminal->column = 0;
1943 terminal->row += 1;
1944 if (terminal->row > terminal->margin_bottom) {
1945 terminal->row = terminal->margin_bottom;
1946 terminal_scroll(terminal, +1);
1947 }
1948 } else {
1949 terminal->column--;
1950 }
1951 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001952
1953 row = terminal_get_row(terminal, terminal->row);
1954 attr_row = terminal_get_attr_row(terminal, terminal->row);
1955
Callum Lowcay69e96582011-01-07 19:47:00 +00001956 if (terminal->mode & MODE_IRM)
1957 terminal_shift_line(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001958 row[terminal->column] = utf8;
1959 attr_row[terminal->column++] = terminal->curr_attr;
1960
Kristian Høgsberg1d781ee2013-11-24 16:54:12 -08001961 if (terminal->row + terminal->start + 1 > terminal->end)
1962 terminal->end = terminal->row + terminal->start + 1;
1963 if (terminal->end == terminal->buffer_height)
1964 terminal->log_size = terminal->buffer_height;
1965 else if (terminal->log_size < terminal->buffer_height)
1966 terminal->log_size = terminal->end;
1967
Peng Wucfcc1112013-08-19 10:59:21 +08001968 /* cursor jump for wide character. */
1969 if (is_wide(utf8))
1970 row[terminal->column++].ch = 0x200B; /* space glyph */
1971
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001972 if (utf8.ch != terminal->last_char.ch)
1973 terminal->last_char = utf8;
1974}
1975
Callum Lowcay30eeae52011-01-07 19:46:55 +00001976static void
Callum Lowcay67a201d2011-01-12 19:23:41 +13001977escape_append_utf8(struct terminal *terminal, union utf8_char utf8)
1978{
1979 int len, i;
1980
1981 if ((utf8.byte[0] & 0x80) == 0x00) len = 1;
1982 else if ((utf8.byte[0] & 0xE0) == 0xC0) len = 2;
1983 else if ((utf8.byte[0] & 0xF0) == 0xE0) len = 3;
1984 else if ((utf8.byte[0] & 0xF8) == 0xF0) len = 4;
1985 else len = 1; /* Invalid, cannot happen */
1986
1987 if (terminal->escape_length + len <= MAX_ESCAPE) {
1988 for (i = 0; i < len; i++)
1989 terminal->escape[terminal->escape_length + i] = utf8.byte[i];
1990 terminal->escape_length += len;
1991 } else if (terminal->escape_length < MAX_ESCAPE) {
1992 terminal->escape[terminal->escape_length++] = 0;
1993 }
1994}
1995
1996static void
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001997terminal_data(struct terminal *terminal, const char *data, size_t length)
1998{
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001999 unsigned int i;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002000 union utf8_char utf8;
2001 enum utf8_state parser_state;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002002
2003 for (i = 0; i < length; i++) {
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002004 parser_state =
2005 utf8_next_char(&terminal->state_machine, data[i]);
2006 switch(parser_state) {
2007 case utf8state_accept:
2008 utf8.ch = terminal->state_machine.s.ch;
2009 break;
2010 case utf8state_reject:
2011 /* the unicode replacement character */
2012 utf8.byte[0] = 0xEF;
2013 utf8.byte[1] = 0xBF;
2014 utf8.byte[2] = 0xBD;
2015 utf8.byte[3] = 0x00;
2016 break;
2017 default:
2018 continue;
2019 }
2020
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002021 /* assume escape codes never use non-ASCII characters */
Callum Lowcay67a201d2011-01-12 19:23:41 +13002022 switch (terminal->state) {
2023 case escape_state_escape:
2024 escape_append_utf8(terminal, utf8);
2025 switch (utf8.byte[0]) {
2026 case 'P': /* DCS */
2027 terminal->state = escape_state_dcs;
2028 break;
2029 case '[': /* CSI */
2030 terminal->state = escape_state_csi;
2031 break;
2032 case ']': /* OSC */
2033 terminal->state = escape_state_osc;
2034 break;
2035 case '#':
2036 case '(':
2037 case ')': /* special */
2038 terminal->state = escape_state_special;
2039 break;
2040 case '^': /* PM (not implemented) */
2041 case '_': /* APC (not implemented) */
2042 terminal->state = escape_state_ignore;
2043 break;
2044 default:
2045 terminal->state = escape_state_normal;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002046 handle_non_csi_escape(terminal, utf8.byte[0]);
Callum Lowcay67a201d2011-01-12 19:23:41 +13002047 break;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002048 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13002049 continue;
2050 case escape_state_csi:
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002051 if (handle_special_char(terminal, utf8.byte[0]) != 0) {
2052 /* do nothing */
2053 } else if (utf8.byte[0] == '?') {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002054 terminal->escape_flags |= ESC_FLAG_WHAT;
2055 } else if (utf8.byte[0] == '>') {
2056 terminal->escape_flags |= ESC_FLAG_GT;
2057 } else if (utf8.byte[0] == '!') {
2058 terminal->escape_flags |= ESC_FLAG_BANG;
2059 } else if (utf8.byte[0] == '$') {
2060 terminal->escape_flags |= ESC_FLAG_CASH;
2061 } else if (utf8.byte[0] == '\'') {
2062 terminal->escape_flags |= ESC_FLAG_SQUOTE;
2063 } else if (utf8.byte[0] == '"') {
2064 terminal->escape_flags |= ESC_FLAG_DQUOTE;
2065 } else if (utf8.byte[0] == ' ') {
2066 terminal->escape_flags |= ESC_FLAG_SPACE;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002067 } else {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002068 escape_append_utf8(terminal, utf8);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002069 if (terminal->escape_length >= MAX_ESCAPE)
Callum Lowcay67a201d2011-01-12 19:23:41 +13002070 terminal->state = escape_state_normal;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002071 }
2072
2073 if (isalpha(utf8.byte[0]) || utf8.byte[0] == '@' ||
2074 utf8.byte[0] == '`')
2075 {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002076 terminal->state = escape_state_normal;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002077 handle_escape(terminal);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002078 } else {
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002079 }
Callum Lowcay67a201d2011-01-12 19:23:41 +13002080 continue;
2081 case escape_state_inner_escape:
2082 if (utf8.byte[0] == '\\') {
2083 terminal->state = escape_state_normal;
2084 if (terminal->outer_state == escape_state_dcs) {
2085 handle_dcs(terminal);
2086 } else if (terminal->outer_state == escape_state_osc) {
2087 handle_osc(terminal);
2088 }
2089 } else if (utf8.byte[0] == '\e') {
2090 terminal->state = terminal->outer_state;
2091 escape_append_utf8(terminal, utf8);
2092 if (terminal->escape_length >= MAX_ESCAPE)
2093 terminal->state = escape_state_normal;
2094 } else {
2095 terminal->state = terminal->outer_state;
2096 if (terminal->escape_length < MAX_ESCAPE)
2097 terminal->escape[terminal->escape_length++] = '\e';
2098 escape_append_utf8(terminal, utf8);
2099 if (terminal->escape_length >= MAX_ESCAPE)
2100 terminal->state = escape_state_normal;
2101 }
2102 continue;
2103 case escape_state_dcs:
2104 case escape_state_osc:
2105 case escape_state_ignore:
2106 if (utf8.byte[0] == '\e') {
2107 terminal->outer_state = terminal->state;
2108 terminal->state = escape_state_inner_escape;
2109 } else if (utf8.byte[0] == '\a' && terminal->state == escape_state_osc) {
2110 terminal->state = escape_state_normal;
2111 handle_osc(terminal);
2112 } else {
2113 escape_append_utf8(terminal, utf8);
2114 if (terminal->escape_length >= MAX_ESCAPE)
2115 terminal->state = escape_state_normal;
2116 }
2117 continue;
2118 case escape_state_special:
2119 escape_append_utf8(terminal, utf8);
2120 terminal->state = escape_state_normal;
2121 if (isdigit(utf8.byte[0]) || isalpha(utf8.byte[0])) {
2122 handle_special_escape(terminal, terminal->escape[1],
2123 utf8.byte[0]);
2124 }
2125 continue;
2126 default:
2127 break;
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05002128 }
2129
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002130 /* this is valid, because ASCII characters are never used to
2131 * introduce a multibyte sequence in UTF-8 */
2132 if (utf8.byte[0] == '\e') {
Callum Lowcay67a201d2011-01-12 19:23:41 +13002133 terminal->state = escape_state_escape;
2134 terminal->outer_state = escape_state_normal;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05002135 terminal->escape[0] = '\e';
2136 terminal->escape_length = 1;
Callum Lowcay67a201d2011-01-12 19:23:41 +13002137 terminal->escape_flags = 0;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00002138 } else {
2139 handle_char(terminal, utf8);
2140 } /* if */
2141 } /* for */
Kristian Høgsberg721f09f2008-12-08 11:13:26 -05002142
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04002143 window_schedule_redraw(terminal->window);
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002144}
2145
2146static void
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002147data_source_target(void *data,
2148 struct wl_data_source *source, const char *mime_type)
2149{
2150 fprintf(stderr, "data_source_target, %s\n", mime_type);
2151}
2152
2153static void
2154data_source_send(void *data,
2155 struct wl_data_source *source,
2156 const char *mime_type, int32_t fd)
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002157{
Kristian Høgsberg31cce052011-01-21 15:18:55 -05002158 struct terminal *terminal = data;
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002159
Kristian Høgsberg31cce052011-01-21 15:18:55 -05002160 terminal_send_selection(terminal, fd);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002161}
2162
2163static void
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002164data_source_cancelled(void *data, struct wl_data_source *source)
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002165{
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002166 wl_data_source_destroy(source);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002167}
2168
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002169static const struct wl_data_source_listener data_source_listener = {
2170 data_source_target,
2171 data_source_send,
2172 data_source_cancelled
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002173};
2174
Kristian Høgsberg0749e3f2013-09-04 20:41:06 -07002175static const char text_mime_type[] = "text/plain;charset=utf-8";
2176
2177static void
2178data_handler(struct window *window,
2179 struct input *input,
2180 float x, float y, const char **types, void *data)
2181{
2182 int i, has_text = 0;
2183
2184 if (!types)
2185 return;
2186 for (i = 0; types[i]; i++)
2187 if (strcmp(types[i], text_mime_type) == 0)
2188 has_text = 1;
2189
2190 if (!has_text) {
2191 input_accept(input, NULL);
2192 } else {
2193 input_accept(input, text_mime_type);
2194 }
2195}
2196
2197static void
2198drop_handler(struct window *window, struct input *input,
2199 int32_t x, int32_t y, void *data)
2200{
2201 struct terminal *terminal = data;
2202
2203 input_receive_drag_data_to_fd(input, text_mime_type, terminal->master);
2204}
2205
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002206static void
2207fullscreen_handler(struct window *window, void *data)
2208{
2209 struct terminal *terminal = data;
2210
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002211 window_set_fullscreen(window, !window_is_fullscreen(terminal->window));
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002212}
2213
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002214static void
Jasper St. Pierrebf175902013-11-12 20:19:58 -05002215close_handler(void *data)
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002216{
2217 struct terminal *terminal = data;
2218
2219 terminal_destroy(terminal);
2220}
2221
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002222static void
2223terminal_copy(struct terminal *terminal, struct input *input)
2224{
2225 terminal->selection =
2226 display_create_data_source(terminal->display);
2227 wl_data_source_offer(terminal->selection,
2228 "text/plain;charset=utf-8");
2229 wl_data_source_add_listener(terminal->selection,
2230 &data_source_listener, terminal);
2231 input_set_selection(input, terminal->selection,
2232 display_get_serial(terminal->display));
2233}
2234
2235static void
2236terminal_paste(struct terminal *terminal, struct input *input)
2237{
2238 input_receive_selection_data_to_fd(input,
2239 "text/plain;charset=utf-8",
2240 terminal->master);
2241
2242}
2243
2244static void
2245terminal_new_instance(struct terminal *terminal)
2246{
2247 struct terminal *new_terminal;
2248
2249 new_terminal = terminal_create(terminal->display);
2250 if (terminal_run(new_terminal, option_shell))
2251 terminal_destroy(new_terminal);
2252}
2253
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002254static int
2255handle_bound_key(struct terminal *terminal,
2256 struct input *input, uint32_t sym, uint32_t time)
2257{
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002258 switch (sym) {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002259 case XKB_KEY_X:
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002260 /* Cut selection; terminal doesn't do cut, fall
2261 * through to copy. */
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002262 case XKB_KEY_C:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002263 terminal_copy(terminal, input);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002264 return 1;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002265 case XKB_KEY_V:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002266 terminal_paste(terminal, input);
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002267 return 1;
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002268 case XKB_KEY_N:
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002269 terminal_new_instance(terminal);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002270 return 1;
2271
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002272 case XKB_KEY_Up:
2273 if (!terminal->scrolling)
2274 terminal->saved_start = terminal->start;
2275 if (terminal->start == terminal->end - terminal->log_size)
2276 return 1;
2277
2278 terminal->scrolling = 1;
2279 terminal->start--;
2280 terminal->row++;
2281 terminal->selection_start_row++;
2282 terminal->selection_end_row++;
2283 widget_schedule_redraw(terminal->widget);
2284 return 1;
2285
2286 case XKB_KEY_Down:
2287 if (!terminal->scrolling)
2288 terminal->saved_start = terminal->start;
2289
2290 if (terminal->start == terminal->saved_start)
2291 return 1;
2292
2293 terminal->scrolling = 1;
2294 terminal->start++;
2295 terminal->row--;
2296 terminal->selection_start_row--;
2297 terminal->selection_end_row--;
2298 widget_schedule_redraw(terminal->widget);
2299 return 1;
2300
Kristian Høgsberg58eec362011-01-19 14:27:42 -05002301 default:
2302 return 0;
2303 }
2304}
2305
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002306static void
2307key_handler(struct window *window, struct input *input, uint32_t time,
Daniel Stonec9785ea2012-05-30 16:31:52 +01002308 uint32_t key, uint32_t sym, enum wl_keyboard_key_state state,
2309 void *data)
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002310{
2311 struct terminal *terminal = data;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00002312 char ch[MAX_RESPONSE];
Kristian Høgsberg88fd4082012-06-21 15:55:03 -04002313 uint32_t modifiers, serial;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002314 int ret, len = 0, d;
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002315 bool convert_utf8 = true;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002316
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002317 modifiers = input_get_modifiers(input);
Kristian Høgsberg70163132012-05-08 15:55:39 -04002318 if ((modifiers & MOD_CONTROL_MASK) &&
2319 (modifiers & MOD_SHIFT_MASK) &&
Daniel Stonec9785ea2012-05-30 16:31:52 +01002320 state == WL_KEYBOARD_KEY_STATE_PRESSED &&
2321 handle_bound_key(terminal, input, sym, time))
Kristian Høgsberg67cac8a2011-01-19 14:20:33 -05002322 return;
2323
Daniel Stonea8468712012-11-07 17:51:35 +11002324 /* Map keypad symbols to 'normal' equivalents before processing */
2325 switch (sym) {
2326 case XKB_KEY_KP_Space:
2327 sym = XKB_KEY_space;
2328 break;
2329 case XKB_KEY_KP_Tab:
2330 sym = XKB_KEY_Tab;
2331 break;
2332 case XKB_KEY_KP_Enter:
2333 sym = XKB_KEY_Return;
2334 break;
2335 case XKB_KEY_KP_Left:
2336 sym = XKB_KEY_Left;
2337 break;
2338 case XKB_KEY_KP_Up:
2339 sym = XKB_KEY_Up;
2340 break;
2341 case XKB_KEY_KP_Right:
2342 sym = XKB_KEY_Right;
2343 break;
2344 case XKB_KEY_KP_Down:
2345 sym = XKB_KEY_Down;
2346 break;
2347 case XKB_KEY_KP_Equal:
2348 sym = XKB_KEY_equal;
2349 break;
2350 case XKB_KEY_KP_Multiply:
2351 sym = XKB_KEY_asterisk;
2352 break;
2353 case XKB_KEY_KP_Add:
2354 sym = XKB_KEY_plus;
2355 break;
2356 case XKB_KEY_KP_Separator:
2357 /* Note this is actually locale-dependent and should mostly be
2358 * a comma. But leave it as period until we one day start
2359 * doing the right thing. */
2360 sym = XKB_KEY_period;
2361 break;
2362 case XKB_KEY_KP_Subtract:
2363 sym = XKB_KEY_minus;
2364 break;
2365 case XKB_KEY_KP_Decimal:
2366 sym = XKB_KEY_period;
2367 break;
2368 case XKB_KEY_KP_Divide:
2369 sym = XKB_KEY_slash;
2370 break;
2371 case XKB_KEY_KP_0:
2372 case XKB_KEY_KP_1:
2373 case XKB_KEY_KP_2:
2374 case XKB_KEY_KP_3:
2375 case XKB_KEY_KP_4:
2376 case XKB_KEY_KP_5:
2377 case XKB_KEY_KP_6:
2378 case XKB_KEY_KP_7:
2379 case XKB_KEY_KP_8:
2380 case XKB_KEY_KP_9:
2381 sym = (sym - XKB_KEY_KP_0) + XKB_KEY_0;
2382 break;
2383 default:
2384 break;
2385 }
2386
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002387 switch (sym) {
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002388 case XKB_KEY_BackSpace:
Kristian Høgsbergb7f94bf2012-06-21 12:29:36 -04002389 if (modifiers & MOD_ALT_MASK)
2390 ch[len++] = 0x1b;
Kristian Høgsberg71a4cf42012-06-20 17:57:56 -04002391 ch[len++] = 0x7f;
2392 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002393 case XKB_KEY_Tab:
2394 case XKB_KEY_Linefeed:
2395 case XKB_KEY_Clear:
2396 case XKB_KEY_Pause:
2397 case XKB_KEY_Scroll_Lock:
2398 case XKB_KEY_Sys_Req:
2399 case XKB_KEY_Escape:
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002400 ch[len++] = sym & 0x7f;
2401 break;
2402
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002403 case XKB_KEY_Return:
Callum Lowcay8e57dd52011-01-07 19:46:59 +00002404 if (terminal->mode & MODE_LF_NEWLINE) {
2405 ch[len++] = 0x0D;
2406 ch[len++] = 0x0A;
2407 } else {
2408 ch[len++] = 0x0D;
2409 }
2410 break;
2411
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002412 case XKB_KEY_Shift_L:
2413 case XKB_KEY_Shift_R:
2414 case XKB_KEY_Control_L:
2415 case XKB_KEY_Control_R:
2416 case XKB_KEY_Alt_L:
2417 case XKB_KEY_Alt_R:
Kristian Høgsberg22fbcf72012-06-22 12:18:56 -04002418 case XKB_KEY_Meta_L:
2419 case XKB_KEY_Meta_R:
2420 case XKB_KEY_Super_L:
2421 case XKB_KEY_Super_R:
2422 case XKB_KEY_Hyper_L:
2423 case XKB_KEY_Hyper_R:
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002424 break;
2425
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002426 case XKB_KEY_Insert:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002427 len = function_key_response('[', 2, modifiers, '~', ch);
2428 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002429 case XKB_KEY_Delete:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002430 if (terminal->mode & MODE_DELETE_SENDS_DEL) {
2431 ch[len++] = '\x04';
2432 } else {
2433 len = function_key_response('[', 3, modifiers, '~', ch);
2434 }
2435 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002436 case XKB_KEY_Page_Up:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002437 len = function_key_response('[', 5, modifiers, '~', ch);
2438 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002439 case XKB_KEY_Page_Down:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002440 len = function_key_response('[', 6, modifiers, '~', ch);
2441 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002442 case XKB_KEY_F1:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002443 len = function_key_response('O', 1, modifiers, 'P', ch);
2444 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002445 case XKB_KEY_F2:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002446 len = function_key_response('O', 1, modifiers, 'Q', ch);
2447 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002448 case XKB_KEY_F3:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002449 len = function_key_response('O', 1, modifiers, 'R', ch);
2450 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002451 case XKB_KEY_F4:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002452 len = function_key_response('O', 1, modifiers, 'S', ch);
2453 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002454 case XKB_KEY_F5:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002455 len = function_key_response('[', 15, modifiers, '~', ch);
2456 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002457 case XKB_KEY_F6:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002458 len = function_key_response('[', 17, modifiers, '~', ch);
2459 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002460 case XKB_KEY_F7:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002461 len = function_key_response('[', 18, modifiers, '~', ch);
2462 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002463 case XKB_KEY_F8:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002464 len = function_key_response('[', 19, modifiers, '~', ch);
2465 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002466 case XKB_KEY_F9:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002467 len = function_key_response('[', 20, modifiers, '~', ch);
2468 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002469 case XKB_KEY_F10:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002470 len = function_key_response('[', 21, modifiers, '~', ch);
2471 break;
Kristian Høgsbergbef52d12012-05-11 11:24:29 -04002472 case XKB_KEY_F12:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002473 len = function_key_response('[', 24, modifiers, '~', ch);
2474 break;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002475 default:
Callum Lowcay7e08e902011-01-07 19:47:02 +00002476 /* Handle special keys with alternate mappings */
2477 len = apply_key_map(terminal->key_mode, sym, modifiers, ch);
2478 if (len != 0) break;
2479
Kristian Høgsberg70163132012-05-08 15:55:39 -04002480 if (modifiers & MOD_CONTROL_MASK) {
Callum Lowcay7e08e902011-01-07 19:47:02 +00002481 if (sym >= '3' && sym <= '7')
2482 sym = (sym & 0x1f) + 8;
2483
2484 if (!((sym >= '!' && sym <= '/') ||
2485 (sym >= '8' && sym <= '?') ||
2486 (sym >= '0' && sym <= '2'))) sym = sym & 0x1f;
2487 else if (sym == '2') sym = 0x00;
2488 else if (sym == '/') sym = 0x1F;
2489 else if (sym == '8' || sym == '?') sym = 0x7F;
Kristian Høgsbergae9e0732012-06-21 12:30:15 -04002490 }
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002491 if (modifiers & MOD_ALT_MASK) {
2492 if (terminal->mode & MODE_ALT_SENDS_ESC) {
2493 ch[len++] = 0x1b;
2494 } else {
2495 sym = sym | 0x80;
2496 convert_utf8 = false;
2497 }
Callum Lowcay7e08e902011-01-07 19:47:02 +00002498 }
2499
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002500 if ((sym < 128) ||
2501 (!convert_utf8 && sym < 256)) {
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002502 ch[len++] = sym;
Philipp Brüschweilerfdb4b022012-08-18 13:38:38 +02002503 } else {
2504 ret = xkb_keysym_to_utf8(sym, ch + len,
2505 MAX_RESPONSE - len);
2506 if (ret < 0)
2507 fprintf(stderr,
2508 "Warning: buffer too small to encode "
2509 "UTF8 character\n");
2510 else
2511 len += ret;
2512 }
2513
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002514 break;
2515 }
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04002516
Kristian Høgsbergb24ab802012-06-22 12:17:17 -04002517 if (state == WL_KEYBOARD_KEY_STATE_PRESSED && len > 0) {
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002518 if (terminal->scrolling) {
2519 d = terminal->saved_start - terminal->start;
2520 terminal->row -= d;
2521 terminal->selection_start_row -= d;
2522 terminal->selection_end_row -= d;
2523 terminal->start = terminal->saved_start;
2524 terminal->scrolling = 0;
2525 widget_schedule_redraw(terminal->widget);
2526 }
2527
Kristian Høgsberg26130862011-08-24 11:30:21 -04002528 terminal_write(terminal, ch, len);
Kristian Høgsbergb24ab802012-06-22 12:17:17 -04002529
2530 /* Hide cursor, except if this was coming from a
2531 * repeating key press. */
2532 serial = display_get_serial(terminal->display);
2533 if (terminal->hide_cursor_serial != serial) {
2534 input_set_pointer_image(input, CURSOR_BLANK);
2535 terminal->hide_cursor_serial = serial;
2536 }
2537 }
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002538}
2539
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002540static void
2541keyboard_focus_handler(struct window *window,
Kristian Høgsberg43788b12010-07-28 23:50:12 -04002542 struct input *device, void *data)
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002543{
2544 struct terminal *terminal = data;
2545
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04002546 window_schedule_redraw(terminal->window);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002547}
2548
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002549static int wordsep(int ch)
2550{
2551 const char extra[] = "-,./?%&#:_=+@~";
2552
Andre Heider552d12b2012-08-02 20:59:43 +02002553 if (ch > 127)
2554 return 1;
2555
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002556 return ch == 0 || !(isalpha(ch) || isdigit(ch) || strchr(extra, ch));
2557}
2558
2559static int
2560recompute_selection(struct terminal *terminal)
2561{
2562 struct rectangle allocation;
2563 int col, x, width, height;
2564 int start_row, end_row;
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002565 int word_start, eol;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002566 int side_margin, top_margin;
2567 int start_x, end_x;
2568 int cw, ch;
2569 union utf8_char *data;
2570
Peng Wuf291f202013-06-06 15:32:41 +08002571 cw = terminal->average_width;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002572 ch = terminal->extents.height;
2573 widget_get_allocation(terminal->widget, &allocation);
2574 width = terminal->width * cw;
2575 height = terminal->height * ch;
2576 side_margin = allocation.x + (allocation.width - width) / 2;
2577 top_margin = allocation.y + (allocation.height - height) / 2;
2578
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002579 start_row = (terminal->selection_start_y - top_margin + ch) / ch - 1;
2580 end_row = (terminal->selection_end_y - top_margin + ch) / ch - 1;
2581
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002582 if (start_row < end_row ||
2583 (start_row == end_row &&
2584 terminal->selection_start_x < terminal->selection_end_x)) {
2585 terminal->selection_start_row = start_row;
2586 terminal->selection_end_row = end_row;
2587 start_x = terminal->selection_start_x;
2588 end_x = terminal->selection_end_x;
2589 } else {
2590 terminal->selection_start_row = end_row;
2591 terminal->selection_end_row = start_row;
2592 start_x = terminal->selection_end_x;
2593 end_x = terminal->selection_start_x;
2594 }
2595
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002596 eol = 0;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002597 if (terminal->selection_start_row < 0) {
2598 terminal->selection_start_row = 0;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002599 terminal->selection_start_col = 0;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002600 } else {
2601 x = side_margin + cw / 2;
2602 data = terminal_get_row(terminal,
2603 terminal->selection_start_row);
2604 word_start = 0;
2605 for (col = 0; col < terminal->width; col++, x += cw) {
2606 if (col == 0 || wordsep(data[col - 1].ch))
2607 word_start = col;
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002608 if (data[col].ch != 0)
2609 eol = col + 1;
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002610 if (start_x < x)
2611 break;
2612 }
2613
2614 switch (terminal->dragging) {
2615 case SELECT_LINE:
2616 terminal->selection_start_col = 0;
2617 break;
2618 case SELECT_WORD:
2619 terminal->selection_start_col = word_start;
2620 break;
2621 case SELECT_CHAR:
2622 terminal->selection_start_col = col;
2623 break;
2624 }
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002625 }
2626
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002627 if (terminal->selection_end_row >= terminal->height) {
2628 terminal->selection_end_row = terminal->height;
2629 terminal->selection_end_col = 0;
2630 } else {
2631 x = side_margin + cw / 2;
2632 data = terminal_get_row(terminal, terminal->selection_end_row);
2633 for (col = 0; col < terminal->width; col++, x += cw) {
2634 if (terminal->dragging == SELECT_CHAR && end_x < x)
2635 break;
2636 if (terminal->dragging == SELECT_WORD &&
2637 end_x < x && wordsep(data[col].ch))
2638 break;
2639 }
Kristian Høgsberg8268d412012-06-29 11:35:24 -04002640 terminal->selection_end_col = col;
2641 }
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002642
Kristian Høgsberg0fe782b2012-07-01 21:31:46 -04002643 if (terminal->selection_end_col != terminal->selection_start_col ||
2644 terminal->selection_start_row != terminal->selection_end_row) {
2645 col = terminal->selection_end_col;
2646 if (col > 0 && data[col - 1].ch == 0)
2647 terminal->selection_end_col = terminal->width;
2648 data = terminal_get_row(terminal, terminal->selection_start_row);
2649 if (data[terminal->selection_start_col].ch == 0)
2650 terminal->selection_start_col = eol;
2651 }
2652
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002653 return 1;
2654}
2655
Kristian Høgsberg59826582011-01-20 11:56:57 -05002656static void
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002657menu_func(struct window *window, struct input *input, int index, void *data)
2658{
2659 struct terminal *terminal = data;
2660
2661 fprintf(stderr, "picked entry %d\n", index);
2662
2663 switch (index) {
2664 case 0:
2665 terminal_new_instance(terminal);
2666 break;
2667 case 1:
2668 terminal_copy(terminal, input);
2669 break;
2670 case 2:
2671 terminal_paste(terminal, input);
2672 break;
2673 }
2674}
2675
2676static void
2677show_menu(struct terminal *terminal, struct input *input, uint32_t time)
2678{
2679 int32_t x, y;
2680 static const char *entries[] = {
2681 "Open Terminal", "Copy", "Paste"
2682 };
2683
2684 input_get_position(input, &x, &y);
2685 window_show_menu(terminal->display, input, time, terminal->window,
2686 x - 10, y - 10, menu_func,
2687 entries, ARRAY_LENGTH(entries));
2688}
2689
2690static void
Kristian Høgsberga8a0db32012-01-09 11:12:05 -05002691button_handler(struct widget *widget,
Kristian Høgsberg59826582011-01-20 11:56:57 -05002692 struct input *input, uint32_t time,
Daniel Stone4dbadb12012-05-30 16:31:51 +01002693 uint32_t button,
2694 enum wl_pointer_button_state state, void *data)
Kristian Høgsberg59826582011-01-20 11:56:57 -05002695{
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002696 struct terminal *terminal = data;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002697
2698 switch (button) {
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002699 case BTN_LEFT:
Daniel Stone4dbadb12012-05-30 16:31:51 +01002700 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002701
2702 if (time - terminal->button_time < 500)
2703 terminal->click_count++;
2704 else
2705 terminal->click_count = 1;
2706
2707 terminal->button_time = time;
2708 terminal->dragging =
2709 (terminal->click_count - 1) % 3 + SELECT_CHAR;
2710
Kristian Høgsberg59826582011-01-20 11:56:57 -05002711 input_get_position(input,
2712 &terminal->selection_start_x,
2713 &terminal->selection_start_y);
2714 terminal->selection_end_x = terminal->selection_start_x;
2715 terminal->selection_end_y = terminal->selection_start_y;
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002716 if (recompute_selection(terminal))
2717 widget_schedule_redraw(widget);
Kristian Høgsberg59826582011-01-20 11:56:57 -05002718 } else {
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002719 terminal->dragging = SELECT_NONE;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002720 }
2721 break;
Kristian Høgsberg67b82152013-10-23 16:52:05 -07002722
2723 case BTN_RIGHT:
2724 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
2725 show_menu(terminal, input, time);
2726 break;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002727 }
2728}
2729
2730static int
Kristian Høgsberg29784402012-06-28 14:27:02 -04002731enter_handler(struct widget *widget,
2732 struct input *input, float x, float y, void *data)
2733{
Kristian Høgsberga83be202013-10-23 20:47:35 -07002734 struct terminal *terminal = data;
2735
2736 /* Reset title to get rid of resizing '[WxH]' in titlebar */
2737 window_set_title(terminal->window, terminal->title);
2738
Kristian Høgsberg29784402012-06-28 14:27:02 -04002739 return CURSOR_IBEAM;
2740}
2741
2742static int
Kristian Høgsberg5f190ef2012-01-09 09:44:45 -05002743motion_handler(struct widget *widget,
Kristian Høgsberg59826582011-01-20 11:56:57 -05002744 struct input *input, uint32_t time,
Kristian Høgsberg80680c72012-05-10 12:21:37 -04002745 float x, float y, void *data)
Kristian Høgsberg59826582011-01-20 11:56:57 -05002746{
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002747 struct terminal *terminal = data;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002748
2749 if (terminal->dragging) {
Kristian Høgsberg59826582011-01-20 11:56:57 -05002750 input_get_position(input,
2751 &terminal->selection_end_x,
2752 &terminal->selection_end_y);
Kristian Høgsberg333db0a2012-06-27 17:43:10 -04002753
2754 if (recompute_selection(terminal))
2755 widget_schedule_redraw(widget);
Kristian Høgsberg59826582011-01-20 11:56:57 -05002756 }
2757
Ander Conselvan de Oliveiradc8c8fc2012-05-25 16:01:41 +03002758 return CURSOR_IBEAM;
Kristian Høgsberg59826582011-01-20 11:56:57 -05002759}
2760
Alexander Larssonde79dd02013-05-22 14:41:34 +02002761static void
2762output_handler(struct window *window, struct output *output, int enter,
2763 void *data)
2764{
2765 if (enter)
2766 window_set_buffer_transform(window, output_get_transform(output));
2767 window_set_buffer_scale(window, window_get_output_scale(window));
2768 window_schedule_redraw(window);
2769}
2770
Peng Wuf291f202013-06-06 15:32:41 +08002771#ifndef howmany
2772#define howmany(x, y) (((x) + ((y) - 1)) / (y))
2773#endif
2774
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002775static struct terminal *
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002776terminal_create(struct display *display)
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002777{
2778 struct terminal *terminal;
Kristian Høgsberg09531622010-06-14 23:22:15 -04002779 cairo_surface_t *surface;
2780 cairo_t *cr;
Peng Wuf291f202013-06-06 15:32:41 +08002781 cairo_text_extents_t text_extents;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002782
Peter Huttererf3d62272013-08-08 11:57:05 +10002783 terminal = xzalloc(sizeof *terminal);
Callum Lowcay30eeae52011-01-07 19:46:55 +00002784 terminal->color_scheme = &DEFAULT_COLORS;
2785 terminal_init(terminal);
Callum Lowcaybbeac602011-01-07 19:46:58 +00002786 terminal->margin_top = 0;
Callum Lowcay86653ed2011-01-07 19:47:03 +00002787 terminal->margin_bottom = -1;
Kristian Høgsberg009ac0a2012-01-31 15:24:48 -05002788 terminal->window = window_create(display);
Jason Ekstrandee7fefc2013-10-13 19:08:38 -05002789 terminal->widget = window_frame_create(terminal->window, terminal);
Kristian Høgsberga83be202013-10-23 20:47:35 -07002790 terminal->title = strdup("Wayland Terminal");
2791 window_set_title(terminal->window, terminal->title);
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05002792 widget_set_transparent(terminal->widget, 0);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002793
2794 init_state_machine(&terminal->state_machine);
Callum Lowcay30eeae52011-01-07 19:46:55 +00002795 init_color_table(terminal);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00002796
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002797 terminal->display = display;
Kristian Høgsberg1584c572008-12-08 12:59:37 -05002798 terminal->margin = 5;
Kristian Høgsberg14f39b22013-10-23 16:29:14 -07002799 terminal->buffer_height = 1024;
2800 terminal->end = 1;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05002801
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002802 window_set_user_data(terminal->window, terminal);
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002803 window_set_key_handler(terminal->window, key_handler);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05002804 window_set_keyboard_focus_handler(terminal->window,
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04002805 keyboard_focus_handler);
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002806 window_set_fullscreen_handler(terminal->window, fullscreen_handler);
Alexander Larssonde79dd02013-05-22 14:41:34 +02002807 window_set_output_handler(terminal->window, output_handler);
Dima Ryazanovd20fd4d2013-01-28 01:11:06 -08002808 window_set_close_handler(terminal->window, close_handler);
Kristian Høgsberg67ace202012-07-23 21:56:31 -04002809
Kristian Høgsberg0749e3f2013-09-04 20:41:06 -07002810 window_set_data_handler(terminal->window, data_handler);
2811 window_set_drop_handler(terminal->window, drop_handler);
2812
Kristian Høgsbergb67e94b2012-01-10 12:23:19 -05002813 widget_set_redraw_handler(terminal->widget, redraw_handler);
2814 widget_set_resize_handler(terminal->widget, resize_handler);
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002815 widget_set_button_handler(terminal->widget, button_handler);
Kristian Høgsberg29784402012-06-28 14:27:02 -04002816 widget_set_enter_handler(terminal->widget, enter_handler);
Kristian Høgsberg75bc6672012-01-10 09:43:58 -05002817 widget_set_motion_handler(terminal->widget, motion_handler);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002818
Kristian Høgsberg09531622010-06-14 23:22:15 -04002819 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
2820 cr = cairo_create(surface);
Kristian Høgsberg38912df2012-06-27 17:52:23 -04002821 cairo_set_font_size(cr, option_font_size);
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002822 cairo_select_font_face (cr, option_font,
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05002823 CAIRO_FONT_SLANT_NORMAL,
2824 CAIRO_FONT_WEIGHT_BOLD);
2825 terminal->font_bold = cairo_get_scaled_font (cr);
2826 cairo_scaled_font_reference(terminal->font_bold);
2827
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002828 cairo_select_font_face (cr, option_font,
Kristian Høgsberg7ae6b1a2010-12-25 16:58:31 -05002829 CAIRO_FONT_SLANT_NORMAL,
2830 CAIRO_FONT_WEIGHT_NORMAL);
2831 terminal->font_normal = cairo_get_scaled_font (cr);
2832 cairo_scaled_font_reference(terminal->font_normal);
2833
Kristian Høgsberg09531622010-06-14 23:22:15 -04002834 cairo_font_extents(cr, &terminal->extents);
Peng Wuf291f202013-06-06 15:32:41 +08002835
2836 /* Compute the average ascii glyph width */
2837 cairo_text_extents(cr, TERMINAL_DRAW_SINGLE_WIDE_CHARACTERS,
2838 &text_extents);
2839 terminal->average_width = howmany
2840 (text_extents.width,
2841 strlen(TERMINAL_DRAW_SINGLE_WIDE_CHARACTERS));
2842 terminal->average_width = ceil(terminal->average_width);
2843
Kristian Høgsberg09531622010-06-14 23:22:15 -04002844 cairo_destroy(cr);
2845 cairo_surface_destroy(surface);
2846
Kristian Høgsbergd3a19652012-07-20 11:32:51 -04002847 terminal_resize(terminal, 20, 5); /* Set minimum size first */
Kristian Høgsberga1627922012-06-20 17:30:03 -04002848 terminal_resize(terminal, 80, 25);
Kristian Høgsberg009ac0a2012-01-31 15:24:48 -05002849
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002850 wl_list_insert(terminal_list.prev, &terminal->link);
2851
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002852 return terminal;
2853}
2854
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002855static void
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002856terminal_destroy(struct terminal *terminal)
2857{
Dima Ryazanova85292e2012-11-29 00:27:09 -08002858 display_unwatch_fd(terminal->display, terminal->master);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002859 window_destroy(terminal->window);
2860 close(terminal->master);
2861 wl_list_remove(&terminal->link);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002862
2863 if (wl_list_empty(&terminal_list))
Dima Ryazanova85292e2012-11-29 00:27:09 -08002864 display_exit(terminal->display);
2865
Kristian Høgsberga83be202013-10-23 20:47:35 -07002866 free(terminal->title);
Dima Ryazanova85292e2012-11-29 00:27:09 -08002867 free(terminal);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002868}
2869
2870static void
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002871io_handler(struct task *task, uint32_t events)
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002872{
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002873 struct terminal *terminal =
2874 container_of(task, struct terminal, io_task);
2875 char buffer[256];
2876 int len;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002877
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002878 if (events & EPOLLHUP) {
2879 terminal_destroy(terminal);
2880 return;
2881 }
Tim Wiederhakef71accc2011-01-19 23:14:33 +01002882
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002883 len = read(terminal->master, buffer, sizeof buffer);
2884 if (len < 0)
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002885 terminal_destroy(terminal);
2886 else
2887 terminal_data(terminal, buffer, len);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002888}
2889
2890static int
2891terminal_run(struct terminal *terminal, const char *path)
2892{
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05002893 int master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002894 pid_t pid;
2895
2896 pid = forkpty(&master, NULL, NULL, NULL);
2897 if (pid == 0) {
Kristian Høgsbergde845cf2012-06-20 22:14:31 -04002898 setenv("TERM", option_term, 1);
2899 setenv("COLORTERM", option_term, 1);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002900 if (execl(path, path, NULL)) {
2901 printf("exec failed: %m\n");
2902 exit(EXIT_FAILURE);
2903 }
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05002904 } else if (pid < 0) {
2905 fprintf(stderr, "failed to fork and create pty (%m).\n");
2906 return -1;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002907 }
2908
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05002909 terminal->master = master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002910 fcntl(master, F_SETFL, O_NONBLOCK);
Kristian Høgsberg3a696272011-09-14 17:33:48 -04002911 terminal->io_task.run = io_handler;
2912 display_watch_fd(terminal->display, terminal->master,
2913 EPOLLIN | EPOLLHUP, &terminal->io_task);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002914
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002915 window_set_fullscreen(terminal->window, option_fullscreen);
2916 if (!window_is_fullscreen(terminal->window))
Kristian Høgsberg547da5a2011-09-13 20:58:00 -04002917 terminal_resize(terminal, 80, 24);
2918
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05002919 return 0;
2920}
2921
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002922static const struct weston_option terminal_options[] = {
2923 { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &option_fullscreen },
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002924 { WESTON_OPTION_STRING, "font", 0, &option_font },
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002925 { WESTON_OPTION_STRING, "shell", 0, &option_shell },
Kristian Høgsberg0395f302008-12-22 12:14:50 -05002926};
2927
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002928int main(int argc, char *argv[])
2929{
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05002930 struct display *d;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002931 struct terminal *terminal;
Kristian Høgsberg9c3dee12013-09-21 22:23:08 -07002932 struct weston_config *config;
2933 struct weston_config_section *s;
Kristian Høgsberg82cd36b2012-06-20 15:29:07 -04002934
Peng Wucfcc1112013-08-19 10:59:21 +08002935 /* as wcwidth is locale-dependent,
2936 wcwidth needs setlocale call to function properly. */
2937 setlocale(LC_ALL, "");
2938
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002939 option_shell = getenv("SHELL");
2940 if (!option_shell)
2941 option_shell = "/bin/bash";
2942
Kristian Høgsberg1abe0482013-09-21 23:02:31 -07002943 config = weston_config_parse("weston.ini");
Kristian Høgsberg9c3dee12013-09-21 22:23:08 -07002944 s = weston_config_get_section(config, "terminal", NULL, NULL);
2945 weston_config_section_get_string(s, "font", &option_font, "mono");
2946 weston_config_section_get_int(s, "font-size", &option_font_size, 14);
2947 weston_config_section_get_string(s, "term", &option_term, "xterm");
2948 weston_config_destroy(config);
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002949
Kristian Høgsberg4172f662013-02-20 15:27:49 -05002950 d = display_create(&argc, argv);
Yuval Fledele9f5e362010-11-22 21:34:19 +02002951 if (d == NULL) {
2952 fprintf(stderr, "failed to create display: %m\n");
2953 return -1;
2954 }
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002955
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002956 wl_list_init(&terminal_list);
Kristian Høgsbergb7ed4cb2012-10-10 11:37:46 -04002957 terminal = terminal_create(d);
Kristian Høgsbergb21fb9f2012-06-20 22:44:03 -04002958 if (terminal_run(terminal, option_shell))
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05002959 exit(EXIT_FAILURE);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002960
Kristian Høgsberg7824d812010-06-08 14:59:44 -04002961 display_run(d);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05002962
2963 return 0;
2964}