blob: 9e77beeb1b73d699de536976d1e08e18b1fbd6ab [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
23#include <stdint.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <fcntl.h>
28#include <unistd.h>
29#include <math.h>
30#include <time.h>
Kristian Høgsberg269d6e32008-12-07 23:17:31 -050031#include <pty.h>
Kristian Høgsbergf04e8382008-12-08 00:07:49 -050032#include <ctype.h>
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050033#include <cairo.h>
34#include <glib.h>
35
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -040036#include <X11/keysym.h>
37
Kristian Høgsberg12308a42009-09-28 13:08:50 -040038#include "wayland-util.h"
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050039#include "wayland-client.h"
40#include "wayland-glib.h"
41
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050042#include "window.h"
43
Kristian Høgsberg0395f302008-12-22 12:14:50 -050044static int option_fullscreen;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -050045
Kristian Høgsberg6e83d582008-12-08 00:01:36 -050046#define MOD_SHIFT 0x01
47#define MOD_ALT 0x02
48#define MOD_CTRL 0x04
49
Callum Lowcay30eeae52011-01-07 19:46:55 +000050#define ATTRMASK_BOLD 0x01
51#define ATTRMASK_UNDERLINE 0x02
52#define ATTRMASK_BLINK 0x04
53#define ATTRMASK_INVERSE 0x08
54
Callum Lowcayb8609ad2011-01-07 19:46:57 +000055/* Buffer sizes */
56#define MAX_RESPONSE 11
57#define MAX_ESCAPE 64
58
Callum Lowcay8e57dd52011-01-07 19:46:59 +000059/* Terminal modes */
60#define MODE_SHOW_CURSOR 0x00000001
61#define MODE_INVERSE 0x00000002
62#define MODE_AUTOWRAP 0x00000004
63#define MODE_AUTOREPEAT 0x00000008
64#define MODE_LF_NEWLINE 0x00000010
Callum Lowcay69e96582011-01-07 19:47:00 +000065#define MODE_IRM 0x00000020
Callum Lowcay7e08e902011-01-07 19:47:02 +000066#define MODE_DELETE_SENDS_DEL 0x00000040
67#define MODE_ALT_SENDS_ESC 0x00000080
Callum Lowcay8e57dd52011-01-07 19:46:59 +000068
Callum Lowcay15bdc5d2011-01-07 19:46:54 +000069union utf8_char {
70 unsigned char byte[4];
71 uint32_t ch;
72};
73
74enum utf8_state {
75 utf8state_start,
76 utf8state_accept,
77 utf8state_reject,
78 utf8state_expect3,
79 utf8state_expect2,
80 utf8state_expect1
81};
82
83struct utf8_state_machine {
84 enum utf8_state state;
85 int len;
86 union utf8_char s;
87};
88
89static void
90init_state_machine(struct utf8_state_machine *machine)
91{
92 machine->state = utf8state_start;
93 machine->len = 0;
94 machine->s.ch = 0;
95}
96
97static enum utf8_state
98utf8_next_char(struct utf8_state_machine *machine, char c)
99{
100 switch(machine->state) {
101 case utf8state_start:
102 case utf8state_accept:
103 case utf8state_reject:
104 machine->s.ch = 0;
105 machine->len = 0;
106 if(c == 0xC0 || c == 0xC1) {
107 /* overlong encoding, reject */
108 machine->state = utf8state_reject;
109 } else if((c & 0x80) == 0) {
110 /* single byte, accept */
111 machine->s.byte[machine->len++] = c;
112 machine->state = utf8state_accept;
113 } else if((c & 0xC0) == 0x80) {
114 /* parser out of sync, ignore byte */
115 machine->state = utf8state_start;
116 } else if((c & 0xE0) == 0xC0) {
117 /* start of two byte sequence */
118 machine->s.byte[machine->len++] = c;
119 machine->state = utf8state_expect1;
120 } else if((c & 0xF0) == 0xE0) {
121 /* start of three byte sequence */
122 machine->s.byte[machine->len++] = c;
123 machine->state = utf8state_expect2;
124 } else if((c & 0xF8) == 0xF0) {
125 /* start of four byte sequence */
126 machine->s.byte[machine->len++] = c;
127 machine->state = utf8state_expect3;
128 } else {
129 /* overlong encoding, reject */
130 machine->state = utf8state_reject;
131 }
132 break;
133 case utf8state_expect3:
134 machine->s.byte[machine->len++] = c;
135 if((c & 0xC0) == 0x80) {
136 /* all good, continue */
137 machine->state = utf8state_expect2;
138 } else {
139 /* missing extra byte, reject */
140 machine->state = utf8state_reject;
141 }
142 break;
143 case utf8state_expect2:
144 machine->s.byte[machine->len++] = c;
145 if((c & 0xC0) == 0x80) {
146 /* all good, continue */
147 machine->state = utf8state_expect1;
148 } else {
149 /* missing extra byte, reject */
150 machine->state = utf8state_reject;
151 }
152 break;
153 case utf8state_expect1:
154 machine->s.byte[machine->len++] = c;
155 if((c & 0xC0) == 0x80) {
156 /* all good, accept */
157 machine->state = utf8state_accept;
158 } else {
159 /* missing extra byte, reject */
160 machine->state = utf8state_reject;
161 }
162 break;
163 default:
164 machine->state = utf8state_reject;
165 break;
166 }
167
168 return machine->state;
169}
170
Callum Lowcay256e72f2011-01-07 19:47:01 +0000171struct char_sub {
172 union utf8_char match;
173 union utf8_char replace;
174};
175/* Set last char_sub match to NULL char */
176typedef struct char_sub *character_set;
177
178struct char_sub CS_US[] = {
179 {{{0, }}, {{0, }}}
180};
181static struct char_sub CS_UK[] = {
182 {{{'#', 0, }}, {{0xC2, 0xA3, 0, }}},
183 {{{0, }}, {{0, }}}
184};
185static struct char_sub CS_SPECIAL[] = {
186 {{{'`', 0, }}, {{0xE2, 0x99, 0xA6, 0}}}, /* diamond */
187 {{{'a', 0, }}, {{0xE2, 0x96, 0x92, 0}}}, /* 50% cell */
188 {{{'b', 0, }}, {{0xE2, 0x90, 0x89, 0}}}, /* HT */
189 {{{'c', 0, }}, {{0xE2, 0x90, 0x8C, 0}}}, /* FF */
190 {{{'d', 0, }}, {{0xE2, 0x90, 0x8D, 0}}}, /* CR */
191 {{{'e', 0, }}, {{0xE2, 0x90, 0x8A, 0}}}, /* LF */
192 {{{'f', 0, }}, {{0xC2, 0xB0, 0, }}}, /* Degree */
193 {{{'g', 0, }}, {{0xC2, 0xB1, 0, }}}, /* Plus/Minus */
194 {{{'h', 0, }}, {{0xE2, 0x90, 0xA4, 0}}}, /* NL */
195 {{{'i', 0, }}, {{0xE2, 0x90, 0x8B, 0}}}, /* VT */
196 {{{'j', 0, }}, {{0xE2, 0x94, 0x98, 0}}}, /* CN_RB */
197 {{{'k', 0, }}, {{0xE2, 0x94, 0x90, 0}}}, /* CN_RT */
198 {{{'l', 0, }}, {{0xE2, 0x94, 0x8C, 0}}}, /* CN_LT */
199 {{{'m', 0, }}, {{0xE2, 0x94, 0x94, 0}}}, /* CN_RB */
200 {{{'n', 0, }}, {{0xE2, 0x94, 0xBC, 0}}}, /* CROSS */
201 {{{'o', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* H */
202 {{{'p', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* H */
203 {{{'q', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* H */
204 {{{'r', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* H */
205 {{{'s', 0, }}, {{0xE2, 0x94, 0x80, 0}}}, /* H */
206 {{{'t', 0, }}, {{0xE2, 0x94, 0x9C, 0}}}, /* TR */
207 {{{'u', 0, }}, {{0xE2, 0x94, 0xA4, 0}}}, /* TL */
208 {{{'v', 0, }}, {{0xE2, 0x94, 0xB4, 0}}}, /* TU */
209 {{{'w', 0, }}, {{0xE2, 0x94, 0xAC, 0}}}, /* TD */
210 {{{'x', 0, }}, {{0xE2, 0x94, 0x82, 0}}}, /* V */
211 {{{'y', 0, }}, {{0xE2, 0x89, 0xA4, 0}}}, /* LE */
212 {{{'z', 0, }}, {{0xE2, 0x89, 0xA5, 0}}}, /* GE */
213 {{{'{', 0, }}, {{0xCF, 0x80, 0, }}}, /* PI */
214 {{{'|', 0, }}, {{0xE2, 0x89, 0xA0, 0}}}, /* NEQ */
215 {{{'}', 0, }}, {{0xC2, 0xA3, 0, }}}, /* POUND */
216 {{{'~', 0, }}, {{0xE2, 0x8B, 0x85, 0}}}, /* DOT */
217 {{{0, }}, {{0, }}}
218};
219
220static void
221apply_char_set(character_set cs, union utf8_char *utf8)
222{
223 int i = 0;
224
225 while (cs[i].match.byte[0]) {
226 if ((*utf8).ch == cs[i].match.ch) {
227 *utf8 = cs[i].replace;
228 break;
229 }
230 i++;
231 }
232}
233
Callum Lowcay7e08e902011-01-07 19:47:02 +0000234struct key_map {
235 int sym;
236 int num;
237 char escape;
238 char code;
239};
240/* Set last key_sub sym to NULL */
241typedef struct key_map *keyboard_mode;
242
243static struct key_map KM_NORMAL[] = {
244 {XK_Left, 1, '[', 'D'},
245 {XK_Right, 1, '[', 'C'},
246 {XK_Up, 1, '[', 'A'},
247 {XK_Down, 1, '[', 'B'},
248 {XK_Home, 1, '[', 'H'},
249 {XK_End, 1, '[', 'F'},
250 {0, 0, 0, 0}
251};
252static struct key_map KM_APPLICATION[] = {
253 {XK_Left, 1, 'O', 'D'},
254 {XK_Right, 1, 'O', 'C'},
255 {XK_Up, 1, 'O', 'A'},
256 {XK_Down, 1, 'O', 'B'},
257 {XK_Home, 1, 'O', 'H'},
258 {XK_End, 1, 'O', 'F'},
259 {XK_KP_Enter, 1, 'O', 'M'},
260 {XK_KP_Multiply, 1, 'O', 'j'},
261 {XK_KP_Add, 1, 'O', 'k'},
262 {XK_KP_Separator, 1, 'O', 'l'},
263 {XK_KP_Subtract, 1, 'O', 'm'},
264 {XK_KP_Divide, 1, 'O', 'o'},
265 {0, 0, 0, 0}
266};
267
268static int
269function_key_response(char escape, int num, uint32_t modifiers,
270 char code, char *response)
271{
272 int mod_num = 0;
273 int len;
274
275 if (modifiers & WINDOW_MODIFIER_SHIFT) mod_num |= 1;
276 if (modifiers & WINDOW_MODIFIER_ALT) mod_num |= 2;
277 if (modifiers & WINDOW_MODIFIER_CONTROL) mod_num |= 4;
278
279 if (mod_num != 0)
280 len = snprintf(response, MAX_RESPONSE, "\e[%d;%d%c",
281 num, mod_num + 1, code);
282 else if (code != '~')
283 len = snprintf(response, MAX_RESPONSE, "\e%c%c",
284 escape, code);
285 else
286 len = snprintf(response, MAX_RESPONSE, "\e%c%d%c",
287 escape, num, code);
288
289 if (len >= MAX_RESPONSE) return MAX_RESPONSE - 1;
290 else return len;
291}
292
293/* returns the number of bytes written into response,
294 * which must have room for MAX_RESPONSE bytes */
295static int
296apply_key_map(keyboard_mode mode, int sym, uint32_t modifiers, char *response)
297{
298 struct key_map map;
299 int len = 0;
300 int i = 0;
301
302 while (mode[i].sym) {
303 map = mode[i++];
304 if (sym == map.sym) {
305 len = function_key_response(map.escape, map.num,
306 modifiers, map.code,
307 response);
308 break;
309 }
310 }
311
312 return len;
313}
314
Callum Lowcay30eeae52011-01-07 19:46:55 +0000315struct terminal_color { double r, g, b, a; };
316struct attr {
317 unsigned char fg, bg;
318 char a; /* attributes format:
319 * 76543210
320 * ilub */
321 char r; /* reserved */
322};
323struct color_scheme {
324 struct terminal_color palette[16];
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500325 char border;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000326 struct attr default_attr;
327};
328
329static void
330attr_init(struct attr *data_attr, struct attr attr, int n)
331{
332 int i;
333 for (i = 0; i < n; i++) {
334 data_attr[i] = attr;
335 }
336}
337
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500338struct terminal {
339 struct window *window;
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -0500340 struct display *display;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000341 union utf8_char *data;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000342 char *tab_ruler;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000343 struct attr *data_attr;
344 struct attr curr_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000345 uint32_t mode;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000346 char origin_mode;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000347 char saved_origin_mode;
348 struct attr saved_attr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000349 union utf8_char last_char;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000350 int margin_top, margin_bottom;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000351 character_set cs, g0, g1;
352 character_set saved_cs, saved_g0, saved_g1;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000353 keyboard_mode key_mode;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000354 int data_pitch, attr_pitch; /* The width in bytes of a line */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500355 int width, height, start, row, column;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000356 int saved_row, saved_column;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -0500357 int fd, master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -0500358 GIOChannel *channel;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -0500359 uint32_t modifiers;
Callum Lowcayb8609ad2011-01-07 19:46:57 +0000360 char escape[MAX_ESCAPE];
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500361 int escape_length;
Kristian Høgsbergf04e8382008-12-08 00:07:49 -0500362 int state;
Callum Lowcayb8609ad2011-01-07 19:46:57 +0000363 int qmark_flag;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000364 struct utf8_state_machine state_machine;
Kristian Høgsberg1584c572008-12-08 12:59:37 -0500365 int margin;
Kristian Høgsberg0395f302008-12-22 12:14:50 -0500366 int fullscreen;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -0500367 int focused;
Kristian Høgsberg12308a42009-09-28 13:08:50 -0400368 struct color_scheme *color_scheme;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000369 struct terminal_color color_table[256];
Kristian Høgsberg09531622010-06-14 23:22:15 -0400370 cairo_font_extents_t extents;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000371 cairo_font_face_t *font_normal, *font_bold;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500372};
373
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000374/* Create default tab stops, every 8 characters */
375static void
376terminal_init_tabs(struct terminal *terminal)
377{
378 int i = 0;
379
380 while (i < terminal->width) {
381 if (i % 8 == 0)
382 terminal->tab_ruler[i] = 1;
383 else
384 terminal->tab_ruler[i] = 0;
385 i++;
386 }
387}
388
Callum Lowcay30eeae52011-01-07 19:46:55 +0000389static void
390terminal_init(struct terminal *terminal)
391{
392 terminal->curr_attr = terminal->color_scheme->default_attr;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000393 terminal->origin_mode = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000394 terminal->mode = MODE_SHOW_CURSOR |
395 MODE_AUTOREPEAT |
Callum Lowcay7e08e902011-01-07 19:47:02 +0000396 MODE_ALT_SENDS_ESC |
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000397 MODE_AUTOWRAP;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000398
399 terminal->row = 0;
400 terminal->column = 0;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000401
Callum Lowcay256e72f2011-01-07 19:47:01 +0000402 terminal->g0 = CS_US;
403 terminal->g1 = CS_US;
404 terminal->cs = terminal->g0;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000405 terminal->key_mode = KM_NORMAL;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000406
407 terminal->saved_g0 = terminal->g0;
408 terminal->saved_g1 = terminal->g1;
409 terminal->saved_cs = terminal->cs;
410
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000411 terminal->saved_attr = terminal->curr_attr;
412 terminal->saved_origin_mode = terminal->origin_mode;
413 terminal->saved_row = terminal->row;
414 terminal->saved_column = terminal->column;
415
416 if (terminal->tab_ruler != NULL) terminal_init_tabs(terminal);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000417}
418
419static void
420init_color_table(struct terminal *terminal)
421{
422 int c, r;
423 struct terminal_color *color_table = terminal->color_table;
424
425 for (c = 0; c < 256; c ++) {
426 if (c < 16) {
427 color_table[c] = terminal->color_scheme->palette[c];
428 } else if (c < 232) {
429 r = c - 16;
430 color_table[c].b = ((double)(r % 6) / 6.0); r /= 6;
431 color_table[c].g = ((double)(r % 6) / 6.0); r /= 6;
432 color_table[c].r = ((double)(r % 6) / 6.0);
433 color_table[c].a = 1.0;
434 } else {
435 r = (c - 232) * 10 + 8;
436 color_table[c].r = ((double) r) / 256.0;
437 color_table[c].g = color_table[c].r;
438 color_table[c].b = color_table[c].r;
439 color_table[c].a = 1.0;
440 }
441 }
442}
443
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000444static union utf8_char *
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500445terminal_get_row(struct terminal *terminal, int row)
446{
447 int index;
448
449 index = (row + terminal->start) % terminal->height;
450
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000451 return &terminal->data[index * terminal->width];
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500452}
453
Callum Lowcay30eeae52011-01-07 19:46:55 +0000454static struct attr*
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500455terminal_get_attr_row(struct terminal *terminal, int row)
456{
Callum Lowcay30eeae52011-01-07 19:46:55 +0000457 int index;
458
459 index = (row + terminal->start) % terminal->height;
460
461 return &terminal->data_attr[index * terminal->width];
462}
463
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500464struct decoded_attr {
465 int foreground;
466 int background;
467 int bold;
468 int underline;
469};
470
471static void
472terminal_decode_attr(struct terminal *terminal, int row, int col,
473 struct decoded_attr *decoded)
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500474{
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500475 struct attr attr;
476 int foreground, background, tmp;
477
478 /* get the attributes for this character cell */
479 attr = terminal_get_attr_row(terminal, row)[col];
480 if ((attr.a & ATTRMASK_INVERSE) ||
481 ((terminal->mode & MODE_SHOW_CURSOR) &&
482 terminal->focused && terminal->row == row &&
483 terminal->column == col)) {
484 foreground = attr.bg;
485 background = attr.fg;
486 if (attr.a & ATTRMASK_BOLD) {
487 if (foreground <= 16) foreground |= 0x08;
488 if (background <= 16) background &= 0x07;
489 }
490 } else {
491 foreground = attr.fg;
492 background = attr.bg;
493 }
494
495 if (terminal->mode & MODE_INVERSE) {
496 tmp = foreground;
497 foreground = background;
498 background = tmp;
499 if (attr.a & ATTRMASK_BOLD) {
500 if (foreground <= 16) foreground |= 0x08;
501 if (background <= 16) background &= 0x07;
502 }
503 }
504
505 decoded->foreground = foreground;
506 decoded->background = background;
507 decoded->bold = attr.a & (ATTRMASK_BOLD | ATTRMASK_BLINK);
508 decoded->underline = attr.a & ATTRMASK_UNDERLINE;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000509}
510
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500511static void
Callum Lowcaybbeac602011-01-07 19:46:58 +0000512terminal_scroll_buffer(struct terminal *terminal, int d)
513{
514 int i;
515
516 d = d % (terminal->height + 1);
517 terminal->start = (terminal->start + d) % terminal->height;
518 if (terminal->start < 0) terminal->start = terminal->height + terminal->start;
519 if(d < 0) {
520 d = 0 - d;
521 for(i = 0; i < d; i++) {
522 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
523 attr_init(terminal_get_attr_row(terminal, i),
524 terminal->curr_attr, terminal->width);
525 }
526 } else {
527 for(i = terminal->height - d; i < terminal->height; i++) {
528 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
529 attr_init(terminal_get_attr_row(terminal, i),
530 terminal->curr_attr, terminal->width);
531 }
532 }
533}
534
535static void
536terminal_scroll_window(struct terminal *terminal, int d)
537{
538 int i;
539 int window_height;
540 int from_row, to_row;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000541
542 // scrolling range is inclusive
543 window_height = terminal->margin_bottom - terminal->margin_top + 1;
544 d = d % (window_height + 1);
545 if(d < 0) {
546 d = 0 - d;
547 to_row = terminal->margin_bottom;
548 from_row = terminal->margin_bottom - d;
549
550 for (i = 0; i < (window_height - d); i++) {
551 memcpy(terminal_get_row(terminal, to_row - i),
552 terminal_get_row(terminal, from_row - i),
553 terminal->data_pitch);
554 memcpy(terminal_get_attr_row(terminal, to_row - i),
555 terminal_get_attr_row(terminal, from_row - i),
556 terminal->attr_pitch);
557 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000558 for (i = terminal->margin_top; i < (terminal->margin_top + d); i++) {
559 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000560 attr_init(terminal_get_attr_row(terminal, i),
561 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000562 }
563 } else {
564 to_row = terminal->margin_top;
565 from_row = terminal->margin_top + d;
566
567 for (i = 0; i < (window_height - d); i++) {
568 memcpy(terminal_get_row(terminal, to_row + i),
569 terminal_get_row(terminal, from_row + i),
570 terminal->data_pitch);
571 memcpy(terminal_get_attr_row(terminal, to_row + i),
572 terminal_get_attr_row(terminal, from_row + i),
573 terminal->attr_pitch);
574 }
Callum Lowcaybbeac602011-01-07 19:46:58 +0000575 for (i = terminal->margin_bottom - d + 1; i <= terminal->margin_bottom; i++) {
576 memset(terminal_get_row(terminal, i), 0, terminal->data_pitch);
Callum Lowcay86653ed2011-01-07 19:47:03 +0000577 attr_init(terminal_get_attr_row(terminal, i),
578 terminal->curr_attr, terminal->width);
Callum Lowcaybbeac602011-01-07 19:46:58 +0000579 }
580 }
581}
582
583static void
584terminal_scroll(struct terminal *terminal, int d)
585{
586 if(terminal->margin_top == 0 && terminal->margin_bottom == terminal->height - 1)
587 terminal_scroll_buffer(terminal, d);
588 else
589 terminal_scroll_window(terminal, d);
590}
591
592static void
Callum Lowcay69e96582011-01-07 19:47:00 +0000593terminal_shift_line(struct terminal *terminal, int d)
594{
595 union utf8_char *row;
596 struct attr *attr_row, attr;
597
598 row = terminal_get_row(terminal, terminal->row);
599 attr_row = terminal_get_attr_row(terminal, terminal->row);
600
601 if ((terminal->width + d) <= terminal->column)
602 d = terminal->column + 1 - terminal->width;
603 if ((terminal->column + d) >= terminal->width)
604 d = terminal->width - terminal->column - 1;
605
606 if (d < 0) {
607 d = 0 - d;
608 memmove(&row[terminal->column],
609 &row[terminal->column + d],
610 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
611 attr = attr_row[terminal->width - 1];
612 memmove(&attr_row[terminal->column], &attr_row[terminal->column + d],
613 (terminal->width - terminal->column - d) * sizeof(struct attr));
614 memset(&row[terminal->width - d], 0, d * sizeof(union utf8_char));
615 attr_init(&attr_row[terminal->width - d], terminal->curr_attr, d);
616 } else {
617 memmove(&row[terminal->column + d], &row[terminal->column],
618 (terminal->width - terminal->column - d) * sizeof(union utf8_char));
619 memmove(&attr_row[terminal->column + d], &attr_row[terminal->column],
620 (terminal->width - terminal->column - d) * sizeof(struct attr));
621 memset(&row[terminal->column], 0, d * sizeof(union utf8_char));
622 attr_init(&attr_row[terminal->column], terminal->curr_attr, d);
623 }
624}
625
626static void
Kristian Høgsberg22106762008-12-08 13:50:07 -0500627terminal_resize(struct terminal *terminal, int width, int height)
628{
629 size_t size;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000630 union utf8_char *data;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000631 struct attr *data_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000632 char *tab_ruler;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000633 int data_pitch, attr_pitch;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500634 int i, l, total_rows, start;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500635 struct rectangle allocation;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000636 struct winsize ws;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500637 int32_t pixel_width, pixel_height;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500638
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500639 if (width < 1)
640 width = 1;
641 if (height < 1)
642 height = 1;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500643 if (terminal->width == width && terminal->height == height)
644 return;
645
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500646 if (!terminal->fullscreen) {
647 pixel_width = width *
648 terminal->extents.max_x_advance + 2 * terminal->margin;
649 pixel_height = height *
650 terminal->extents.height + 2 * terminal->margin;
651 window_set_child_size(terminal->window,
652 pixel_width, pixel_height);
653 }
654
655 window_schedule_redraw (terminal->window);
656
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000657 data_pitch = width * sizeof(union utf8_char);
658 size = data_pitch * height;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500659 data = malloc(size);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000660 attr_pitch = width * sizeof(struct attr);
661 data_attr = malloc(attr_pitch * height);
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000662 tab_ruler = malloc(width);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500663 memset(data, 0, size);
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000664 memset(tab_ruler, 0, width);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000665 attr_init(data_attr, terminal->curr_attr, width * height);
666 if (terminal->data && terminal->data_attr) {
Kristian Høgsberg22106762008-12-08 13:50:07 -0500667 if (width > terminal->width)
668 l = terminal->width;
669 else
670 l = width;
671
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500672 if (terminal->height > height) {
Kristian Høgsberg22106762008-12-08 13:50:07 -0500673 total_rows = height;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500674 start = terminal->height - height;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500675 } else {
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500676 total_rows = terminal->height;
677 start = 0;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500678 }
679
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000680 for (i = 0; i < total_rows; i++) {
681 memcpy(&data[width * i],
682 terminal_get_row(terminal, i),
683 l * sizeof(union utf8_char));
Callum Lowcay30eeae52011-01-07 19:46:55 +0000684 memcpy(&data_attr[width * i],
685 terminal_get_attr_row(terminal, i),
686 l * sizeof(struct attr));
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000687 }
Kristian Høgsberg22106762008-12-08 13:50:07 -0500688
689 free(terminal->data);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000690 free(terminal->data_attr);
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000691 free(terminal->tab_ruler);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500692 }
693
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000694 terminal->data_pitch = data_pitch;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000695 terminal->attr_pitch = attr_pitch;
Callum Lowcay86653ed2011-01-07 19:47:03 +0000696 terminal->margin_bottom =
697 height - (terminal->height - terminal->margin_bottom);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500698 terminal->width = width;
699 terminal->height = height;
700 terminal->data = data;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000701 terminal->data_attr = data_attr;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000702 terminal->tab_ruler = tab_ruler;
703 terminal_init_tabs(terminal);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500704
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000705 /* Update the window size */
706 ws.ws_row = terminal->height;
707 ws.ws_col = terminal->width;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500708 window_get_child_allocation(terminal->window, &allocation);
709 ws.ws_xpixel = allocation.width;
710 ws.ws_ypixel = allocation.height;
Callum Lowcaya0ee21c2011-01-07 19:46:56 +0000711 ioctl(terminal->master, TIOCSWINSZ, &ws);
Kristian Høgsberg22106762008-12-08 13:50:07 -0500712}
713
Callum Lowcay30eeae52011-01-07 19:46:55 +0000714struct color_scheme DEFAULT_COLORS = {
715 {
716 {0, 0, 0, 1}, /* black */
717 {0.66, 0, 0, 1}, /* red */
718 {0 , 0.66, 0, 1}, /* green */
719 {0.66, 0.33, 0, 1}, /* orange (nicer than muddy yellow) */
720 {0 , 0 , 0.66, 1}, /* blue */
721 {0.66, 0 , 0.66, 1}, /* magenta */
722 {0, 0.66, 0.66, 1}, /* cyan */
723 {0.66, 0.66, 0.66, 1}, /* light grey */
724 {0.22, 0.33, 0.33, 1}, /* dark grey */
725 {1, 0.33, 0.33, 1}, /* high red */
726 {0.33, 1, 0.33, 1}, /* high green */
727 {1, 1, 0.33, 1}, /* high yellow */
728 {0.33, 0.33, 1, 1}, /* high blue */
729 {1, 0.33, 1, 1}, /* high magenta */
730 {0.33, 1, 1, 1}, /* high cyan */
731 {1, 1, 1, 1} /* white */
732 },
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500733 0, /* black border */
Callum Lowcay30eeae52011-01-07 19:46:55 +0000734 {7, 0, 0, } /* bg:black (0), fg:light gray (7) */
735};
Kristian Høgsberg12308a42009-09-28 13:08:50 -0400736
Kristian Høgsberg22106762008-12-08 13:50:07 -0500737static void
Kristian Høgsbergf106fd52011-01-11 10:11:39 -0500738terminal_set_color(struct terminal *terminal, cairo_t *cr, int index)
739{
740 cairo_set_source_rgba(cr,
741 terminal->color_table[index].r,
742 terminal->color_table[index].g,
743 terminal->color_table[index].b,
744 terminal->color_table[index].a);
745}
746
747static void
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500748terminal_draw_contents(struct terminal *terminal)
749{
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500750 struct rectangle allocation;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500751 cairo_t *cr;
752 cairo_font_extents_t extents;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000753 int top_margin, side_margin;
754 int row, col;
755 union utf8_char *p_row;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500756 struct decoded_attr attr;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000757 int text_x, text_y;
Kristian Høgsberg2aac3022009-12-21 10:04:53 -0500758 cairo_surface_t *surface;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -0500759 double d;
Kristian Høgsberg4f506702010-12-25 16:14:23 -0500760 int num_glyphs;
761 cairo_scaled_font_t *font;
762 cairo_glyph_t glyphs[256], *g;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000763
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500764 window_get_child_allocation(terminal->window, &allocation);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500765
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500766 surface = display_create_surface(terminal->display, &allocation);
Kristian Høgsberg2aac3022009-12-21 10:04:53 -0500767 cr = cairo_create(surface);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500768 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
Kristian Høgsberg71eca892011-01-11 10:13:00 -0500769 terminal_set_color(terminal, cr, terminal->color_scheme->border);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500770 cairo_paint(cr);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500771
Callum Lowcay30eeae52011-01-07 19:46:55 +0000772 cairo_set_font_face(cr, terminal->font_normal);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -0500773 cairo_set_font_size(cr, 14);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500774
775 cairo_font_extents(cr, &extents);
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500776 side_margin = (allocation.width - terminal->width * extents.max_x_advance) / 2;
777 top_margin = (allocation.height - terminal->height * extents.height) / 2;
Kristian Høgsberg0395f302008-12-22 12:14:50 -0500778
Callum Lowcay30eeae52011-01-07 19:46:55 +0000779 cairo_set_line_width(cr, 1.0);
780
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500781 /* paint the background */
782 for (row = 0; row < terminal->height; row++) {
783 p_row = terminal_get_row(terminal, row);
784 for (col = 0; col < terminal->width; col++) {
785 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500786 terminal_decode_attr(terminal, row, col, &attr);
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500787
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500788 if (attr.background == terminal->color_scheme->border)
Kristian Høgsbergfb266a32011-01-11 10:15:21 -0500789 continue;
790
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500791 terminal_set_color(terminal, cr, attr.background);
Kristian Høgsberg8c254202010-12-25 08:58:46 -0500792 cairo_move_to(cr, side_margin + (col * extents.max_x_advance),
793 top_margin + (row * extents.height));
794 cairo_rel_line_to(cr, extents.max_x_advance, 0);
795 cairo_rel_line_to(cr, 0, extents.height);
796 cairo_rel_line_to(cr, -extents.max_x_advance, 0);
797 cairo_close_path(cr);
798 cairo_fill(cr);
799 }
800 }
801
802 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
803
804 /* paint the foreground */
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000805 for (row = 0; row < terminal->height; row++) {
806 p_row = terminal_get_row(terminal, row);
807 for (col = 0; col < terminal->width; col++) {
Callum Lowcay30eeae52011-01-07 19:46:55 +0000808 /* get the attributes for this character cell */
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500809 terminal_decode_attr(terminal, row, col, &attr);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000810
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500811 if (attr.bold)
Callum Lowcay30eeae52011-01-07 19:46:55 +0000812 cairo_set_font_face(cr, terminal->font_bold);
813 else
814 cairo_set_font_face(cr, terminal->font_normal);
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500815 terminal_set_color(terminal, cr, attr.foreground);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000816 text_x = side_margin + col * extents.max_x_advance;
817 text_y = top_margin + extents.ascent + row * extents.height;
Kristian Høgsberg01994a52011-01-11 10:26:04 -0500818 if (attr.underline) {
Callum Lowcay86653ed2011-01-07 19:47:03 +0000819 cairo_move_to(cr, text_x, (double)text_y + 1.5);
820 cairo_line_to(cr, text_x + extents.max_x_advance, (double) text_y + 1.5);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000821 cairo_stroke(cr);
822 }
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000823 cairo_move_to(cr, text_x, text_y);
Kristian Høgsberg4f506702010-12-25 16:14:23 -0500824
825 g = glyphs;
826 num_glyphs = ARRAY_LENGTH(glyphs);
827 font = cairo_get_scaled_font (cr);
828 cairo_scaled_font_text_to_glyphs (font, text_x, text_y,
829 (char *) p_row[col].byte, 4,
830 &g, &num_glyphs,
831 NULL, NULL, NULL);
832 cairo_show_glyphs (cr, g, num_glyphs);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000833 }
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500834 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -0500835
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000836 if ((terminal->mode & MODE_SHOW_CURSOR) && !terminal->focused) {
Callum Lowcay30eeae52011-01-07 19:46:55 +0000837 d = 0.5;
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -0500838
Callum Lowcay30eeae52011-01-07 19:46:55 +0000839 cairo_set_line_width(cr, 1);
840 cairo_move_to(cr, side_margin + terminal->column * extents.max_x_advance + d,
841 top_margin + terminal->row * extents.height + d);
842 cairo_rel_line_to(cr, extents.max_x_advance - 2 * d, 0);
843 cairo_rel_line_to(cr, 0, extents.height - 2 * d);
844 cairo_rel_line_to(cr, -extents.max_x_advance + 2 * d, 0);
845 cairo_close_path(cr);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -0500846
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -0500847 cairo_stroke(cr);
Callum Lowcay30eeae52011-01-07 19:46:55 +0000848 }
Kristian Høgsbergb0b82e22009-02-21 15:42:25 -0500849
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500850 cairo_destroy(cr);
851
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500852 window_copy_surface(terminal->window, &allocation, surface);
Kristian Høgsberg2aac3022009-12-21 10:04:53 -0500853
854 cairo_surface_destroy(surface);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500855}
856
857static void
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500858resize_handler(struct window *window,
859 int32_t pixel_width, int32_t pixel_height, void *data)
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500860{
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500861 struct terminal *terminal = data;
Kristian Høgsberg0395f302008-12-22 12:14:50 -0500862 int32_t width, height;
Kristian Høgsberg22106762008-12-08 13:50:07 -0500863
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500864 width = (pixel_width - 2 * terminal->margin) /
Kristian Høgsberg09531622010-06-14 23:22:15 -0400865 (int32_t) terminal->extents.max_x_advance;
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500866 height = (pixel_height - 2 * terminal->margin) /
Kristian Høgsberg09531622010-06-14 23:22:15 -0400867 (int32_t) terminal->extents.height;
Tiago Vignatti5fd89d22011-01-10 19:30:04 +0200868
Kristian Høgsberg22106762008-12-08 13:50:07 -0500869 terminal_resize(terminal, width, height);
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500870}
Kristian Høgsberg22106762008-12-08 13:50:07 -0500871
Kristian Høgsbergda846ca2011-01-11 10:00:52 -0500872static void
873terminal_draw(struct terminal *terminal)
874{
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500875 window_draw(terminal->window);
876 terminal_draw_contents(terminal);
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -0400877 window_flush(terminal->window);
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500878}
879
Kristian Høgsberg80d746f2010-06-14 23:52:50 -0400880static void
881redraw_handler(struct window *window, void *data)
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500882{
883 struct terminal *terminal = data;
884
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -0500885 terminal_draw(terminal);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500886}
887
Kristian Høgsbergf04e8382008-12-08 00:07:49 -0500888#define STATE_NORMAL 0
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500889#define STATE_ESCAPE 1
Callum Lowcayb8609ad2011-01-07 19:46:57 +0000890#define STATE_ESCAPE_SPECIAL 2
891#define STATE_ESCAPE_CSI 3
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500892
893static void
894terminal_data(struct terminal *terminal, const char *data, size_t length);
Kristian Høgsbergf04e8382008-12-08 00:07:49 -0500895
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -0500896static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +0000897handle_char(struct terminal *terminal, union utf8_char utf8);
898
899static void
Callum Lowcay30eeae52011-01-07 19:46:55 +0000900handle_sgr(struct terminal *terminal, int code);
901
902static void
Callum Lowcaybbeac602011-01-07 19:46:58 +0000903handle_term_parameter(struct terminal *terminal, int code, int sr)
904{
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000905 int i;
906
Callum Lowcaybbeac602011-01-07 19:46:58 +0000907 if (terminal->qmark_flag) {
908 switch(code) {
Callum Lowcay7e08e902011-01-07 19:47:02 +0000909 case 1: /* DECCKM */
910 if (sr) terminal->key_mode = KM_APPLICATION;
911 else terminal->key_mode = KM_NORMAL;
912 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +0000913 case 2: /* DECANM */
914 /* No VT52 support yet */
915 terminal->g0 = CS_US;
916 terminal->g1 = CS_US;
917 terminal->cs = terminal->g0;
918 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000919 case 3: /* DECCOLM */
920 if (sr)
921 terminal_resize(terminal, 132, 24);
922 else
923 terminal_resize(terminal, 80, 24);
924
925 /* set columns, but also home cursor and clear screen */
926 terminal->row = 0; terminal->column = 0;
927 for (i = 0; i < terminal->height; i++) {
928 memset(terminal_get_row(terminal, i),
929 0, terminal->data_pitch);
930 attr_init(terminal_get_attr_row(terminal, i),
931 terminal->curr_attr, terminal->width);
932 }
933 break;
934 case 5: /* DECSCNM */
935 if (sr) terminal->mode |= MODE_INVERSE;
936 else terminal->mode &= ~MODE_INVERSE;
937 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000938 case 6: /* DECOM */
939 terminal->origin_mode = sr;
940 if (terminal->origin_mode)
941 terminal->row = terminal->margin_top;
942 else
943 terminal->row = 0;
944 terminal->column = 0;
945 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000946 case 7: /* DECAWM */
947 if (sr) terminal->mode |= MODE_AUTOWRAP;
948 else terminal->mode &= ~MODE_AUTOWRAP;
949 break;
950 case 8: /* DECARM */
951 if (sr) terminal->mode |= MODE_AUTOREPEAT;
952 else terminal->mode &= ~MODE_AUTOREPEAT;
953 break;
954 case 25:
955 if (sr) terminal->mode |= MODE_SHOW_CURSOR;
956 else terminal->mode &= ~MODE_SHOW_CURSOR;
957 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +0000958 case 1037: /* deleteSendsDel */
959 if (sr) terminal->mode |= MODE_DELETE_SENDS_DEL;
960 else terminal->mode &= ~MODE_DELETE_SENDS_DEL;
961 break;
962 case 1039: /* altSendsEscape */
963 if (sr) terminal->mode |= MODE_ALT_SENDS_ESC;
964 else terminal->mode &= ~MODE_ALT_SENDS_ESC;
965 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000966 default:
967 fprintf(stderr, "Unknown parameter: ?%d\n", code);
968 break;
969 }
970 } else {
971 switch(code) {
Callum Lowcay69e96582011-01-07 19:47:00 +0000972 case 4: /* IRM */
973 if (sr) terminal->mode |= MODE_IRM;
974 else terminal->mode &= ~MODE_IRM;
975 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000976 case 20: /* LNM */
977 if (sr) terminal->mode |= MODE_LF_NEWLINE;
978 else terminal->mode &= ~MODE_LF_NEWLINE;
979 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +0000980 default:
981 fprintf(stderr, "Unknown parameter: %d\n", code);
982 break;
983 }
984 }
985}
986
987static void
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500988handle_escape(struct terminal *terminal)
989{
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000990 union utf8_char *row;
Callum Lowcay30eeae52011-01-07 19:46:55 +0000991 struct attr *attr_row;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +0000992 char *p;
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000993 int i, count, x, y, top, bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500994 int args[10], set[10] = { 0, };
Callum Lowcay8e57dd52011-01-07 19:46:59 +0000995 char response[MAX_RESPONSE] = {0, };
Kristian Høgsberg17809b12008-12-08 12:20:40 -0500996
997 terminal->escape[terminal->escape_length++] = '\0';
Kristian Høgsbergdbd54642008-12-08 22:22:25 -0500998 i = 0;
999 p = &terminal->escape[2];
1000 while ((isdigit(*p) || *p == ';') && i < 10) {
1001 if (*p == ';') {
Callum Lowcay30eeae52011-01-07 19:46:55 +00001002 if (!set[i]) {
1003 args[i] = 0;
1004 set[i] = 1;
1005 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001006 p++;
1007 i++;
1008 } else {
1009 args[i] = strtol(p, &p, 10);
1010 set[i] = 1;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001011 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001012 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001013
1014 switch (*p) {
Callum Lowcay69e96582011-01-07 19:47:00 +00001015 case '@': /* ICH */
1016 count = set[0] ? args[0] : 1;
1017 if (count == 0) count = 1;
1018 terminal_shift_line(terminal, count);
1019 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001020 case 'A': /* CUU */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001021 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001022 if (count == 0) count = 1;
1023 if (terminal->row - count >= terminal->margin_top)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001024 terminal->row -= count;
1025 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001026 terminal->row = terminal->margin_top;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001027 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001028 case 'B': /* CUD */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001029 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001030 if (count == 0) count = 1;
1031 if (terminal->row + count <= terminal->margin_bottom)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001032 terminal->row += count;
1033 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001034 terminal->row = terminal->margin_bottom;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001035 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001036 case 'C': /* CUF */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001037 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001038 if (count == 0) count = 1;
1039 if ((terminal->column + count) < terminal->width)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001040 terminal->column += count;
1041 else
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001042 terminal->column = terminal->width - 1;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001043 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001044 case 'D': /* CUB */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001045 count = set[0] ? args[0] : 1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001046 if (count == 0) count = 1;
1047 if ((terminal->column - count) >= 0)
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001048 terminal->column -= count;
1049 else
1050 terminal->column = 0;
1051 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001052 case 'E': /* CNL */
1053 count = set[0] ? args[0] : 1;
1054 if (terminal->row + count <= terminal->margin_bottom)
1055 terminal->row += count;
1056 else
1057 terminal->row = terminal->margin_bottom;
1058 terminal->column = 0;
1059 break;
1060 case 'F': /* CPL */
1061 count = set[0] ? args[0] : 1;
1062 if (terminal->row - count >= terminal->margin_top)
1063 terminal->row -= count;
1064 else
1065 terminal->row = terminal->margin_top;
1066 terminal->column = 0;
1067 break;
1068 case 'G': /* CHA */
1069 y = set[0] ? args[0] : 1;
1070 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1071
1072 terminal->column = y - 1;
1073 break;
1074 case 'f': /* HVP */
1075 case 'H': /* CUP */
1076 x = (set[1] ? args[1] : 1) - 1;
1077 x = x < 0 ? 0 :
1078 (x >= terminal->width ? terminal->width - 1 : x);
1079
1080 y = (set[0] ? args[0] : 1) - 1;
1081 if (terminal->origin_mode) {
1082 y += terminal->margin_top;
1083 y = y < terminal->margin_top ? terminal->margin_top :
1084 (y > terminal->margin_bottom ? terminal->margin_bottom : y);
1085 } else {
1086 y = y < 0 ? 0 :
1087 (y >= terminal->height ? terminal->height - 1 : y);
1088 }
1089
1090 terminal->row = y;
1091 terminal->column = x;
1092 break;
1093 case 'I': /* CHT */
1094 count = set[0] ? args[0] : 1;
1095 if (count == 0) count = 1;
1096 while (count > 0 && terminal->column < terminal->width) {
1097 if (terminal->tab_ruler[terminal->column]) count--;
1098 terminal->column++;
1099 }
1100 terminal->column--;
1101 break;
1102 case 'J': /* ED */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001103 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001104 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001105 if (!set[0] || args[0] == 0 || args[0] > 2) {
1106 memset(&row[terminal->column],
1107 0, (terminal->width - terminal->column) * sizeof(union utf8_char));
1108 attr_init(&attr_row[terminal->column],
1109 terminal->curr_attr, terminal->width - terminal->column);
1110 for (i = terminal->row + 1; i < terminal->height; i++) {
1111 memset(terminal_get_row(terminal, i),
1112 0, terminal->data_pitch);
1113 attr_init(terminal_get_attr_row(terminal, i),
1114 terminal->curr_attr, terminal->width);
1115 }
1116 } else if (args[0] == 1) {
1117 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1118 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1119 for (i = 0; i < terminal->row; i++) {
1120 memset(terminal_get_row(terminal, i),
1121 0, terminal->data_pitch);
1122 attr_init(terminal_get_attr_row(terminal, i),
1123 terminal->curr_attr, terminal->width);
1124 }
1125 } else if (args[0] == 2) {
1126 for (i = 0; i < terminal->height; i++) {
1127 memset(terminal_get_row(terminal, i),
1128 0, terminal->data_pitch);
1129 attr_init(terminal_get_attr_row(terminal, i),
1130 terminal->curr_attr, terminal->width);
1131 }
Callum Lowcay30eeae52011-01-07 19:46:55 +00001132 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001133 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001134 case 'K': /* EL */
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001135 row = terminal_get_row(terminal, terminal->row);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001136 attr_row = terminal_get_attr_row(terminal, terminal->row);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001137 if (!set[0] || args[0] == 0 || args[0] > 2) {
1138 memset(&row[terminal->column], 0,
1139 (terminal->width - terminal->column) * sizeof(union utf8_char));
1140 attr_init(&attr_row[terminal->column], terminal->curr_attr,
1141 terminal->width - terminal->column);
1142 } else if (args[0] == 1) {
1143 memset(row, 0, (terminal->column+1) * sizeof(union utf8_char));
1144 attr_init(attr_row, terminal->curr_attr, terminal->column+1);
1145 } else if (args[0] == 2) {
1146 memset(row, 0, terminal->data_pitch);
1147 attr_init(attr_row, terminal->curr_attr, terminal->width);
1148 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001149 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001150 case 'L': /* IL */
1151 count = set[0] ? args[0] : 1;
1152 if (count == 0) count = 1;
1153 if (terminal->row >= terminal->margin_top &&
1154 terminal->row < terminal->margin_bottom)
1155 {
1156 top = terminal->margin_top;
1157 terminal->margin_top = terminal->row;
1158 terminal_scroll(terminal, 0 - count);
1159 terminal->margin_top = top;
1160 } else if (terminal->row == terminal->margin_bottom) {
1161 memset(terminal_get_row(terminal, terminal->row),
1162 0, terminal->data_pitch);
1163 attr_init(terminal_get_attr_row(terminal, terminal->row),
1164 terminal->curr_attr, terminal->width);
1165 }
1166 break;
1167 case 'M': /* DL */
1168 count = set[0] ? args[0] : 1;
1169 if (count == 0) count = 1;
1170 if (terminal->row >= terminal->margin_top &&
1171 terminal->row < terminal->margin_bottom)
1172 {
1173 top = terminal->margin_top;
1174 terminal->margin_top = terminal->row;
1175 terminal_scroll(terminal, count);
1176 terminal->margin_top = top;
1177 } else if (terminal->row == terminal->margin_bottom) {
1178 memset(terminal_get_row(terminal, terminal->row),
1179 0, terminal->data_pitch);
1180 }
1181 break;
1182 case 'P': /* DCH */
1183 count = set[0] ? args[0] : 1;
1184 if (count == 0) count = 1;
1185 terminal_shift_line(terminal, 0 - count);
1186 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001187 case 'S': /* SU */
1188 terminal_scroll(terminal, set[0] ? args[0] : 1);
1189 break;
1190 case 'T': /* SD */
1191 terminal_scroll(terminal, 0 - (set[0] ? args[0] : 1));
1192 break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001193 case 'X': /* ECH */
1194 count = set[0] ? args[0] : 1;
1195 if (count == 0) count = 1;
1196 if ((terminal->column + count) > terminal->width)
1197 count = terminal->width - terminal->column;
1198 row = terminal_get_row(terminal, terminal->row);
1199 attr_row = terminal_get_attr_row(terminal, terminal->row);
1200 memset(&row[terminal->column], 0, count * sizeof(union utf8_char));
1201 attr_init(&attr_row[terminal->column], terminal->curr_attr, count);
1202 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001203 case 'Z': /* CBT */
1204 count = set[0] ? args[0] : 1;
1205 if (count == 0) count = 1;
1206 while (count > 0 && terminal->column >= 0) {
1207 if (terminal->tab_ruler[terminal->column]) count--;
1208 terminal->column--;
1209 }
1210 terminal->column++;
1211 break;
1212 case '`': /* HPA */
1213 y = set[0] ? args[0] : 1;
1214 y = y <= 0 ? 1 : y > terminal->width ? terminal->width : y;
1215
1216 terminal->column = y - 1;
1217 break;
1218 case 'b': /* REP */
1219 count = set[0] ? args[0] : 1;
1220 if (count == 0) count = 1;
1221 if (terminal->last_char.byte[0])
1222 for (i = 0; i < count; i++)
1223 handle_char(terminal, terminal->last_char);
1224 terminal->last_char.byte[0] = 0;
1225 break;
1226 case 'c': /* Primary DA */
Callum Lowcay69e96582011-01-07 19:47:00 +00001227 write(terminal->master, "\e[?6c", 5);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001228 break;
1229 case 'd': /* VPA */
1230 x = set[0] ? args[0] : 1;
1231 x = x <= 0 ? 1 : x > terminal->height ? terminal->height : x;
1232
1233 terminal->row = x - 1;
1234 break;
1235 case 'g': /* TBC */
1236 if (!set[0] || args[0] == 0) {
1237 terminal->tab_ruler[terminal->column] = 0;
1238 } else if (args[0] == 3) {
1239 memset(terminal->tab_ruler, 0, terminal->width);
1240 }
1241 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001242 case 'h': /* SM */
1243 for(i = 0; i < 10 && set[i]; i++) {
1244 handle_term_parameter(terminal, args[i], 1);
1245 }
1246 break;
1247 case 'l': /* RM */
1248 for(i = 0; i < 10 && set[i]; i++) {
1249 handle_term_parameter(terminal, args[i], 0);
1250 }
1251 break;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001252 case 'm': /* SGR */
1253 if (set[0] && set[1] && set[2] && args[1] == 5) {
1254 if (args[0] == 38) {
1255 handle_sgr(terminal, args[2] + 256);
1256 break;
1257 } else if (args[0] == 48) {
1258 handle_sgr(terminal, args[2] + 512);
1259 break;
1260 }
1261 }
1262 for(i = 0; i < 10; i++) {
1263 if(set[i]) {
1264 handle_sgr(terminal, args[i]);
1265 } else if(i == 0) {
1266 handle_sgr(terminal, 0);
1267 break;
1268 } else {
1269 break;
1270 }
1271 }
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001272 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001273 case 'n': /* DSR */
1274 i = set[0] ? args[0] : 0;
1275 if (i == 0 || i == 5) {
1276 write(terminal->master, "\e[0n", 4);
1277 } else if (i == 6) {
1278 snprintf(response, MAX_RESPONSE, "\e[%d;%dR",
1279 terminal->origin_mode ?
1280 terminal->row+terminal->margin_top : terminal->row+1,
1281 terminal->column+1);
1282 write(terminal->master, response, strlen(response));
1283 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001284 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001285 case 'r':
1286 if(!set[0]) {
1287 terminal->margin_top = 0;
1288 terminal->margin_bottom = terminal->height-1;
1289 terminal->row = 0;
1290 terminal->column = 0;
1291 } else {
1292 top = (set[0] ? args[0] : 1) - 1;
1293 top = top < 0 ? 0 :
1294 (top >= terminal->height ? terminal->height - 1 : top);
1295 bottom = (set[1] ? args[1] : 1) - 1;
1296 bottom = bottom < 0 ? 0 :
1297 (bottom >= terminal->height ? terminal->height - 1 : bottom);
1298 if(bottom > top) {
1299 terminal->margin_top = top;
1300 terminal->margin_bottom = bottom;
1301 } else {
1302 terminal->margin_top = 0;
1303 terminal->margin_bottom = terminal->height-1;
1304 }
1305 if(terminal->origin_mode)
1306 terminal->row = terminal->margin_top;
1307 else
1308 terminal->row = 0;
1309 terminal->column = 0;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001310 }
1311 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001312 case 's':
1313 terminal->saved_row = terminal->row;
1314 terminal->saved_column = terminal->column;
1315 break;
1316 case 'u':
1317 terminal->row = terminal->saved_row;
1318 terminal->column = terminal->saved_column;
1319 break;
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001320 default:
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001321 fprintf(stderr, "Unknown CSI escape: %c\n", *p);
Kristian Høgsbergdbd54642008-12-08 22:22:25 -05001322 break;
1323 }
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001324}
1325
1326static void
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001327handle_non_csi_escape(struct terminal *terminal, char code)
1328{
Callum Lowcaybbeac602011-01-07 19:46:58 +00001329 switch(code) {
1330 case 'M': /* RI */
1331 terminal->row -= 1;
1332 if(terminal->row < terminal->margin_top) {
1333 terminal->row = terminal->margin_top;
1334 terminal_scroll(terminal, -1);
1335 }
1336 break;
1337 case 'E': /* NEL */
1338 terminal->column = 0;
1339 // fallthrough
1340 case 'D': /* IND */
1341 terminal->row += 1;
1342 if(terminal->row > terminal->margin_bottom) {
1343 terminal->row = terminal->margin_bottom;
1344 terminal_scroll(terminal, +1);
1345 }
1346 break;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001347 case 'c': /* RIS */
1348 terminal_init(terminal);
1349 break;
1350 case 'H': /* HTS */
1351 terminal->tab_ruler[terminal->column] = 1;
1352 break;
1353 case '7': /* DECSC */
1354 terminal->saved_row = terminal->row;
1355 terminal->saved_column = terminal->column;
1356 terminal->saved_attr = terminal->curr_attr;
1357 terminal->saved_origin_mode = terminal->origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001358 terminal->saved_cs = terminal->cs;
1359 terminal->saved_g0 = terminal->g0;
1360 terminal->saved_g1 = terminal->g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001361 break;
1362 case '8': /* DECRC */
1363 terminal->row = terminal->saved_row;
1364 terminal->column = terminal->saved_column;
1365 terminal->curr_attr = terminal->saved_attr;
1366 terminal->origin_mode = terminal->saved_origin_mode;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001367 terminal->cs = terminal->saved_cs;
1368 terminal->g0 = terminal->saved_g0;
1369 terminal->g1 = terminal->saved_g1;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001370 break;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001371 case '=': /* DECPAM */
1372 terminal->key_mode = KM_APPLICATION;
1373 break;
1374 case '>': /* DECPNM */
1375 terminal->key_mode = KM_NORMAL;
1376 break;
Callum Lowcaybbeac602011-01-07 19:46:58 +00001377 default:
1378 fprintf(stderr, "Unknown escape code: %c\n", code);
1379 break;
1380 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001381}
1382
1383static void
1384handle_special_escape(struct terminal *terminal, char special, char code)
1385{
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001386 int i, numChars;
1387
1388 if (special == '#') {
1389 switch(code) {
1390 case '8':
1391 /* fill with 'E', no cheap way to do this */
1392 memset(terminal->data, 0, terminal->data_pitch * terminal->height);
1393 numChars = terminal->width * terminal->height;
1394 for(i = 0; i < numChars; i++) {
1395 terminal->data[i].byte[0] = 'E';
1396 }
1397 break;
1398 default:
1399 fprintf(stderr, "Unknown HASH escape #%c\n", code);
1400 break;
1401 }
Callum Lowcay256e72f2011-01-07 19:47:01 +00001402 } else if (special == '(' || special == ')') {
1403 switch(code) {
1404 case '0':
1405 if (special == '(')
1406 terminal->g0 = CS_SPECIAL;
1407 else
1408 terminal->g1 = CS_SPECIAL;
1409 break;
1410 case 'A':
1411 if (special == '(')
1412 terminal->g0 = CS_UK;
1413 else
1414 terminal->g1 = CS_UK;
1415 break;
1416 case 'B':
1417 if (special == '(')
1418 terminal->g0 = CS_US;
1419 else
1420 terminal->g1 = CS_US;
1421 break;
1422 default:
1423 fprintf(stderr, "Unknown character set %c\n", code);
1424 break;
1425 }
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001426 } else {
1427 fprintf(stderr, "Unknown special escape %c%c\n", special, code);
1428 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001429}
1430
1431static void
Callum Lowcay30eeae52011-01-07 19:46:55 +00001432handle_sgr(struct terminal *terminal, int code)
1433{
1434 switch(code) {
1435 case 0:
1436 terminal->curr_attr = terminal->color_scheme->default_attr;
1437 break;
1438 case 1:
1439 terminal->curr_attr.a |= ATTRMASK_BOLD;
1440 if (terminal->curr_attr.fg < 8)
1441 terminal->curr_attr.fg += 8;
1442 break;
1443 case 4:
1444 terminal->curr_attr.a |= ATTRMASK_UNDERLINE;
1445 break;
1446 case 5:
1447 terminal->curr_attr.a |= ATTRMASK_BLINK;
1448 break;
1449 case 2:
1450 case 21:
1451 case 22:
1452 terminal->curr_attr.a &= ~ATTRMASK_BOLD;
1453 if (terminal->curr_attr.fg < 16 && terminal->curr_attr.fg >= 8)
1454 terminal->curr_attr.fg -= 8;
1455 break;
1456 case 24:
1457 terminal->curr_attr.a &= ~ATTRMASK_UNDERLINE;
1458 break;
1459 case 25:
1460 terminal->curr_attr.a &= ~ATTRMASK_BLINK;
1461 break;
1462 case 7:
1463 case 26:
1464 terminal->curr_attr.a |= ATTRMASK_INVERSE;
1465 break;
1466 case 27:
1467 terminal->curr_attr.a &= ~ATTRMASK_INVERSE;
1468 break;
1469 case 39:
1470 terminal->curr_attr.fg = terminal->color_scheme->default_attr.fg;
1471 break;
1472 case 49:
1473 terminal->curr_attr.bg = terminal->color_scheme->default_attr.bg;
1474 break;
1475 default:
1476 if(code >= 30 && code <= 37) {
1477 terminal->curr_attr.fg = code - 30;
1478 if (terminal->curr_attr.a & ATTRMASK_BOLD)
1479 terminal->curr_attr.fg += 8;
1480 } else if(code >= 40 && code <= 47) {
1481 terminal->curr_attr.bg = code - 40;
1482 } else if(code >= 256 && code < 512) {
1483 terminal->curr_attr.fg = code - 256;
1484 } else if(code >= 512 && code < 768) {
1485 terminal->curr_attr.bg = code - 512;
1486 } else {
1487 fprintf(stderr, "Unknown SGR code: %d\n", code);
1488 }
1489 break;
1490 }
1491}
1492
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001493/* Returns 1 if c was special, otherwise 0 */
1494static int
1495handle_special_char(struct terminal *terminal, char c)
1496{
1497 union utf8_char *row;
1498 struct attr *attr_row;
1499
1500 row = terminal_get_row(terminal, terminal->row);
1501 attr_row = terminal_get_attr_row(terminal, terminal->row);
1502
1503 switch(c) {
1504 case '\r':
1505 terminal->column = 0;
1506 break;
1507 case '\n':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001508 if (terminal->mode & MODE_LF_NEWLINE) {
1509 terminal->column = 0;
1510 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001511 /* fallthrough */
1512 case '\v':
1513 case '\f':
Callum Lowcaybbeac602011-01-07 19:46:58 +00001514 terminal->row++;
1515 if(terminal->row > terminal->margin_bottom) {
1516 terminal->row = terminal->margin_bottom;
1517 terminal_scroll(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001518 }
1519
1520 break;
1521 case '\t':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001522 while (terminal->column < terminal->width) {
1523 if (terminal->tab_ruler[terminal->column]) break;
Callum Lowcay69e96582011-01-07 19:47:00 +00001524 if (terminal->mode & MODE_IRM)
1525 terminal_shift_line(terminal, +1);
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001526 row[terminal->column].byte[0] = ' ';
1527 row[terminal->column].byte[1] = '\0';
1528 attr_row[terminal->column] = terminal->curr_attr;
1529 terminal->column++;
1530 }
1531 if (terminal->column >= terminal->width) {
1532 terminal->column = terminal->width - 1;
1533 }
1534
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001535 break;
1536 case '\b':
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001537 if (terminal->column >= terminal->width) {
1538 terminal->column = terminal->width - 2;
1539 } else if (terminal->column > 0) {
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001540 terminal->column--;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001541 } else if (terminal->mode & MODE_AUTOWRAP) {
1542 terminal->column = terminal->width - 1;
1543 terminal->row -= 1;
1544 if (terminal->row < terminal->margin_top) {
1545 terminal->row = terminal->margin_top;
1546 terminal_scroll(terminal, -1);
1547 }
1548 }
1549
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001550 break;
1551 case '\a':
1552 /* Bell */
1553 break;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001554 case '\x0E': /* SO */
1555 terminal->cs = terminal->g1;
1556 break;
1557 case '\x0F': /* SI */
1558 terminal->cs = terminal->g0;
1559 break;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001560 default:
1561 return 0;
1562 }
1563
1564 return 1;
1565}
1566
1567static void
1568handle_char(struct terminal *terminal, union utf8_char utf8)
1569{
1570 union utf8_char *row;
1571 struct attr *attr_row;
1572
1573 if (handle_special_char(terminal, utf8.byte[0])) return;
Callum Lowcay256e72f2011-01-07 19:47:01 +00001574
1575 apply_char_set(terminal->cs, &utf8);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001576
1577 /* There are a whole lot of non-characters, control codes,
1578 * and formatting codes that should probably be ignored,
1579 * for example: */
1580 if (strncmp((char*) utf8.byte, "\xEF\xBB\xBF", 3) == 0) {
1581 /* BOM, ignore */
1582 return;
1583 }
1584
1585 /* Some of these non-characters should be translated, e.g.: */
1586 if (utf8.byte[0] < 32) {
1587 utf8.byte[0] = utf8.byte[0] + 64;
1588 }
1589
1590 /* handle right margin effects */
1591 if (terminal->column >= terminal->width) {
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001592 if (terminal->mode & MODE_AUTOWRAP) {
1593 terminal->column = 0;
1594 terminal->row += 1;
1595 if (terminal->row > terminal->margin_bottom) {
1596 terminal->row = terminal->margin_bottom;
1597 terminal_scroll(terminal, +1);
1598 }
1599 } else {
1600 terminal->column--;
1601 }
1602 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001603
1604 row = terminal_get_row(terminal, terminal->row);
1605 attr_row = terminal_get_attr_row(terminal, terminal->row);
1606
Callum Lowcay69e96582011-01-07 19:47:00 +00001607 if (terminal->mode & MODE_IRM)
1608 terminal_shift_line(terminal, +1);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001609 row[terminal->column] = utf8;
1610 attr_row[terminal->column++] = terminal->curr_attr;
1611
1612 if (utf8.ch != terminal->last_char.ch)
1613 terminal->last_char = utf8;
1614}
1615
Callum Lowcay30eeae52011-01-07 19:46:55 +00001616static void
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001617terminal_data(struct terminal *terminal, const char *data, size_t length)
1618{
1619 int i;
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001620 union utf8_char utf8;
1621 enum utf8_state parser_state;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001622
1623 for (i = 0; i < length; i++) {
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001624 parser_state =
1625 utf8_next_char(&terminal->state_machine, data[i]);
1626 switch(parser_state) {
1627 case utf8state_accept:
1628 utf8.ch = terminal->state_machine.s.ch;
1629 break;
1630 case utf8state_reject:
1631 /* the unicode replacement character */
1632 utf8.byte[0] = 0xEF;
1633 utf8.byte[1] = 0xBF;
1634 utf8.byte[2] = 0xBD;
1635 utf8.byte[3] = 0x00;
1636 break;
1637 default:
1638 continue;
1639 }
1640
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001641 /* assume escape codes never use non-ASCII characters */
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001642 if (terminal->state == STATE_ESCAPE) {
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001643 terminal->escape[terminal->escape_length++] = utf8.byte[0];
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001644 if (utf8.byte[0] == '[') {
1645 terminal->state = STATE_ESCAPE_CSI;
1646 continue;
1647 } else if (utf8.byte[0] == '#' || utf8.byte[0] == '(' ||
1648 utf8.byte[0] == ')')
1649 {
1650 terminal->state = STATE_ESCAPE_SPECIAL;
1651 continue;
1652 } else {
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05001653 terminal->state = STATE_NORMAL;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001654 handle_non_csi_escape(terminal, utf8.byte[0]);
1655 continue;
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001656 }
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001657 } else if (terminal->state == STATE_ESCAPE_SPECIAL) {
1658 terminal->escape[terminal->escape_length++] = utf8.byte[0];
1659 terminal->state = STATE_NORMAL;
1660 if (isdigit(utf8.byte[0]) || isalpha(utf8.byte[0])) {
1661 handle_special_escape(terminal, terminal->escape[1],
1662 utf8.byte[0]);
1663 continue;
1664 }
1665 } else if (terminal->state == STATE_ESCAPE_CSI) {
1666 if (handle_special_char(terminal, utf8.byte[0]) != 0) {
1667 /* do nothing */
1668 } else if (utf8.byte[0] == '?') {
1669 terminal->qmark_flag = 1;
1670 } else {
1671 /* Don't overflow the buffer */
1672 if (terminal->escape_length < MAX_ESCAPE)
1673 terminal->escape[terminal->escape_length++] = utf8.byte[0];
1674 if (terminal->escape_length >= MAX_ESCAPE)
1675 terminal->state = STATE_NORMAL;
1676 }
1677
1678 if (isalpha(utf8.byte[0]) || utf8.byte[0] == '@' ||
1679 utf8.byte[0] == '`')
1680 {
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001681 terminal->state = STATE_NORMAL;
1682 handle_escape(terminal);
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001683 continue;
1684 } else {
1685 continue;
1686 }
Kristian Høgsbergf04e8382008-12-08 00:07:49 -05001687 }
1688
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001689 /* this is valid, because ASCII characters are never used to
1690 * introduce a multibyte sequence in UTF-8 */
1691 if (utf8.byte[0] == '\e') {
Kristian Høgsberg17809b12008-12-08 12:20:40 -05001692 terminal->state = STATE_ESCAPE;
1693 terminal->escape[0] = '\e';
1694 terminal->escape_length = 1;
Callum Lowcayb8609ad2011-01-07 19:46:57 +00001695 terminal->qmark_flag = 0;
1696 } else {
1697 handle_char(terminal, utf8);
1698 } /* if */
1699 } /* for */
Kristian Høgsberg721f09f2008-12-08 11:13:26 -05001700
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04001701 window_schedule_redraw(terminal->window);
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001702}
1703
1704static void
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001705key_handler(struct window *window, uint32_t key, uint32_t sym,
Kristian Høgsberg55444912009-02-21 14:31:09 -05001706 uint32_t state, uint32_t modifiers, void *data)
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001707{
1708 struct terminal *terminal = data;
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001709 char ch[MAX_RESPONSE];
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001710 int len = 0;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001711
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001712 switch (sym) {
1713 case XK_F11:
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001714 if (!state)
1715 break;
1716 terminal->fullscreen ^= 1;
1717 window_set_fullscreen(window, terminal->fullscreen);
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04001718 window_schedule_redraw(terminal->window);
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001719 break;
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001720
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001721 case XK_BackSpace:
1722 case XK_Tab:
1723 case XK_Linefeed:
1724 case XK_Clear:
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001725 case XK_Pause:
1726 case XK_Scroll_Lock:
1727 case XK_Sys_Req:
1728 case XK_Escape:
1729 ch[len++] = sym & 0x7f;
1730 break;
1731
Callum Lowcay8e57dd52011-01-07 19:46:59 +00001732 case XK_Return:
1733 if (terminal->mode & MODE_LF_NEWLINE) {
1734 ch[len++] = 0x0D;
1735 ch[len++] = 0x0A;
1736 } else {
1737 ch[len++] = 0x0D;
1738 }
1739 break;
1740
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001741 case XK_Shift_L:
1742 case XK_Shift_R:
1743 case XK_Control_L:
1744 case XK_Control_R:
1745 case XK_Alt_L:
1746 case XK_Alt_R:
1747 break;
1748
Callum Lowcay7e08e902011-01-07 19:47:02 +00001749 case XK_Insert:
1750 len = function_key_response('[', 2, modifiers, '~', ch);
1751 break;
1752 case XK_Delete:
1753 if (terminal->mode & MODE_DELETE_SENDS_DEL) {
1754 ch[len++] = '\x04';
1755 } else {
1756 len = function_key_response('[', 3, modifiers, '~', ch);
1757 }
1758 break;
1759 case XK_Page_Up:
1760 len = function_key_response('[', 5, modifiers, '~', ch);
1761 break;
1762 case XK_Page_Down:
1763 len = function_key_response('[', 6, modifiers, '~', ch);
1764 break;
1765 case XK_F1:
1766 len = function_key_response('O', 1, modifiers, 'P', ch);
1767 break;
1768 case XK_F2:
1769 len = function_key_response('O', 1, modifiers, 'Q', ch);
1770 break;
1771 case XK_F3:
1772 len = function_key_response('O', 1, modifiers, 'R', ch);
1773 break;
1774 case XK_F4:
1775 len = function_key_response('O', 1, modifiers, 'S', ch);
1776 break;
1777 case XK_F5:
1778 len = function_key_response('[', 15, modifiers, '~', ch);
1779 break;
1780 case XK_F6:
1781 len = function_key_response('[', 17, modifiers, '~', ch);
1782 break;
1783 case XK_F7:
1784 len = function_key_response('[', 18, modifiers, '~', ch);
1785 break;
1786 case XK_F8:
1787 len = function_key_response('[', 19, modifiers, '~', ch);
1788 break;
1789 case XK_F9:
1790 len = function_key_response('[', 20, modifiers, '~', ch);
1791 break;
1792 case XK_F10:
1793 len = function_key_response('[', 21, modifiers, '~', ch);
1794 break;
1795 case XK_F12:
1796 len = function_key_response('[', 24, modifiers, '~', ch);
1797 break;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001798 default:
Callum Lowcay7e08e902011-01-07 19:47:02 +00001799 /* Handle special keys with alternate mappings */
1800 len = apply_key_map(terminal->key_mode, sym, modifiers, ch);
1801 if (len != 0) break;
1802
1803 if (modifiers & WINDOW_MODIFIER_CONTROL) {
1804 if (sym >= '3' && sym <= '7')
1805 sym = (sym & 0x1f) + 8;
1806
1807 if (!((sym >= '!' && sym <= '/') ||
1808 (sym >= '8' && sym <= '?') ||
1809 (sym >= '0' && sym <= '2'))) sym = sym & 0x1f;
1810 else if (sym == '2') sym = 0x00;
1811 else if (sym == '/') sym = 0x1F;
1812 else if (sym == '8' || sym == '?') sym = 0x7F;
1813 } else if ((terminal->mode & MODE_ALT_SENDS_ESC) &&
1814 (modifiers & WINDOW_MODIFIER_ALT))
1815 {
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001816 ch[len++] = 0x1b;
Callum Lowcay7e08e902011-01-07 19:47:02 +00001817 } else if (modifiers & WINDOW_MODIFIER_ALT) {
1818 sym = sym | 0x80;
1819 }
1820
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001821 if (sym < 256)
1822 ch[len++] = sym;
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001823 break;
1824 }
Kristian Høgsberg94adf6c2010-06-25 16:50:05 -04001825
1826 if (state && len > 0)
1827 write(terminal->master, ch, len);
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001828}
1829
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001830static void
1831keyboard_focus_handler(struct window *window,
Kristian Høgsberg43788b12010-07-28 23:50:12 -04001832 struct input *device, void *data)
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001833{
1834 struct terminal *terminal = data;
1835
1836 terminal->focused = (device != NULL);
Kristian Høgsberg80d746f2010-06-14 23:52:50 -04001837 window_schedule_redraw(terminal->window);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001838}
1839
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001840static struct terminal *
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05001841terminal_create(struct display *display, int fullscreen)
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001842{
1843 struct terminal *terminal;
Kristian Høgsberg09531622010-06-14 23:22:15 -04001844 cairo_surface_t *surface;
1845 cairo_t *cr;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001846
1847 terminal = malloc(sizeof *terminal);
1848 if (terminal == NULL)
1849 return terminal;
1850
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001851 memset(terminal, 0, sizeof *terminal);
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001852 terminal->fullscreen = fullscreen;
Callum Lowcay30eeae52011-01-07 19:46:55 +00001853 terminal->color_scheme = &DEFAULT_COLORS;
1854 terminal_init(terminal);
Callum Lowcaybbeac602011-01-07 19:46:58 +00001855 terminal->margin_top = 0;
Callum Lowcay86653ed2011-01-07 19:47:03 +00001856 terminal->margin_bottom = -1;
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05001857 terminal->window = window_create(display, "Wayland Terminal",
Kristian Høgsberg82da52b2010-12-17 09:53:12 -05001858 500, 400);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001859
1860 init_state_machine(&terminal->state_machine);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001861 init_color_table(terminal);
Callum Lowcay15bdc5d2011-01-07 19:46:54 +00001862
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001863 terminal->display = display;
Kristian Høgsberg1584c572008-12-08 12:59:37 -05001864 terminal->margin = 5;
Kristian Høgsberg44e3c5e2008-12-07 21:51:58 -05001865
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001866 window_set_fullscreen(terminal->window, terminal->fullscreen);
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04001867 window_set_user_data(terminal->window, terminal);
1868 window_set_redraw_handler(terminal->window, redraw_handler);
Kristian Høgsbergda846ca2011-01-11 10:00:52 -05001869 window_set_resize_handler(terminal->window, resize_handler);
Kristian Høgsberg94448c02008-12-30 11:03:33 -05001870
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04001871 window_set_key_handler(terminal->window, key_handler);
Kristian Høgsberg3c248cc2009-02-22 23:01:35 -05001872 window_set_keyboard_focus_handler(terminal->window,
Kristian Høgsbergc8c37342010-06-25 11:19:22 -04001873 keyboard_focus_handler);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001874
Kristian Høgsberg09531622010-06-14 23:22:15 -04001875 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
1876 cr = cairo_create(surface);
Callum Lowcay30eeae52011-01-07 19:46:55 +00001877 terminal->font_bold = cairo_toy_font_face_create ("mono",
1878 CAIRO_FONT_SLANT_NORMAL,
1879 CAIRO_FONT_WEIGHT_BOLD);
1880 cairo_font_face_reference(terminal->font_bold);
1881 terminal->font_normal = cairo_toy_font_face_create ("mono",
1882 CAIRO_FONT_SLANT_NORMAL,
1883 CAIRO_FONT_WEIGHT_NORMAL);
1884 cairo_font_face_reference(terminal->font_normal);
1885 cairo_set_font_face(cr, terminal->font_normal);
Kristian Høgsberg09531622010-06-14 23:22:15 -04001886 cairo_set_font_size(cr, 14);
1887 cairo_font_extents(cr, &terminal->extents);
1888 cairo_destroy(cr);
1889 cairo_surface_destroy(surface);
1890
Callum Lowcaya0ee21c2011-01-07 19:46:56 +00001891 terminal_resize(terminal, 80, 24);
Kristian Høgsberg22106762008-12-08 13:50:07 -05001892 terminal_draw(terminal);
1893
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001894 return terminal;
1895}
1896
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001897static gboolean
1898io_handler(GIOChannel *source,
1899 GIOCondition condition,
1900 gpointer data)
1901{
1902 struct terminal *terminal = data;
1903 gchar buffer[256];
1904 gsize bytes_read;
1905 GError *error = NULL;
1906
1907 g_io_channel_read_chars(source, buffer, sizeof buffer,
1908 &bytes_read, &error);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001909
1910 terminal_data(terminal, buffer, bytes_read);
1911
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001912 return TRUE;
1913}
1914
1915static int
1916terminal_run(struct terminal *terminal, const char *path)
1917{
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05001918 int master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001919 pid_t pid;
1920
1921 pid = forkpty(&master, NULL, NULL, NULL);
1922 if (pid == 0) {
Callum Lowcay86653ed2011-01-07 19:47:03 +00001923 setenv("TERM", "xterm-256color", 1);
1924 setenv("COLORTERM", "xterm-256color", 1);
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001925 if (execl(path, path, NULL)) {
1926 printf("exec failed: %m\n");
1927 exit(EXIT_FAILURE);
1928 }
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05001929 } else if (pid < 0) {
1930 fprintf(stderr, "failed to fork and create pty (%m).\n");
1931 return -1;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001932 }
1933
Kristian Høgsberg6e83d582008-12-08 00:01:36 -05001934 terminal->master = master;
Kristian Høgsberg269d6e32008-12-07 23:17:31 -05001935 terminal->channel = g_io_channel_unix_new(master);
1936 fcntl(master, F_SETFL, O_NONBLOCK);
1937 g_io_add_watch(terminal->channel, G_IO_IN,
1938 io_handler, terminal);
1939
1940 return 0;
1941}
1942
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001943static const GOptionEntry option_entries[] = {
1944 { "fullscreen", 'f', 0, G_OPTION_ARG_NONE,
1945 &option_fullscreen, "Run in fullscreen mode" },
1946 { NULL }
1947};
1948
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001949int main(int argc, char *argv[])
1950{
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05001951 struct display *d;
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001952 struct terminal *terminal;
Kristian Høgsberg0395f302008-12-22 12:14:50 -05001953
Kristian Høgsberg7824d812010-06-08 14:59:44 -04001954 d = display_create(&argc, &argv, option_entries);
Yuval Fledele9f5e362010-11-22 21:34:19 +02001955 if (d == NULL) {
1956 fprintf(stderr, "failed to create display: %m\n");
1957 return -1;
1958 }
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001959
Kristian Høgsberg43c28ee2009-01-26 23:42:46 -05001960 terminal = terminal_create(d, option_fullscreen);
Kristian Høgsbergf0c7b202008-12-12 13:39:03 -05001961 if (terminal_run(terminal, "/bin/bash"))
1962 exit(EXIT_FAILURE);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001963
Kristian Høgsberg7824d812010-06-08 14:59:44 -04001964 display_run(d);
Kristian Høgsberg0c4457f2008-12-07 19:59:11 -05001965
1966 return 0;
1967}