Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1 | /* |
| 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øgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 31 | #include <pty.h> |
Kristian Høgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 32 | #include <ctype.h> |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 33 | #include <cairo.h> |
| 34 | #include <glib.h> |
| 35 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 36 | #include <X11/keysym.h> |
| 37 | |
Kristian Høgsberg | 12308a4 | 2009-09-28 13:08:50 -0400 | [diff] [blame] | 38 | #include "wayland-util.h" |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 39 | #include "wayland-client.h" |
| 40 | #include "wayland-glib.h" |
| 41 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 42 | #include "window.h" |
| 43 | |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 44 | static int option_fullscreen; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 45 | |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 46 | #define MOD_SHIFT 0x01 |
| 47 | #define MOD_ALT 0x02 |
| 48 | #define MOD_CTRL 0x04 |
| 49 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 50 | #define ATTRMASK_BOLD 0x01 |
| 51 | #define ATTRMASK_UNDERLINE 0x02 |
| 52 | #define ATTRMASK_BLINK 0x04 |
| 53 | #define ATTRMASK_INVERSE 0x08 |
| 54 | |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 55 | /* Buffer sizes */ |
| 56 | #define MAX_RESPONSE 11 |
| 57 | #define MAX_ESCAPE 64 |
| 58 | |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 59 | /* 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 Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 65 | #define MODE_IRM 0x00000020 |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 66 | #define MODE_DELETE_SENDS_DEL 0x00000040 |
| 67 | #define MODE_ALT_SENDS_ESC 0x00000080 |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 68 | |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 69 | union utf8_char { |
| 70 | unsigned char byte[4]; |
| 71 | uint32_t ch; |
| 72 | }; |
| 73 | |
| 74 | enum utf8_state { |
| 75 | utf8state_start, |
| 76 | utf8state_accept, |
| 77 | utf8state_reject, |
| 78 | utf8state_expect3, |
| 79 | utf8state_expect2, |
| 80 | utf8state_expect1 |
| 81 | }; |
| 82 | |
| 83 | struct utf8_state_machine { |
| 84 | enum utf8_state state; |
| 85 | int len; |
| 86 | union utf8_char s; |
| 87 | }; |
| 88 | |
| 89 | static void |
| 90 | init_state_machine(struct utf8_state_machine *machine) |
| 91 | { |
| 92 | machine->state = utf8state_start; |
| 93 | machine->len = 0; |
| 94 | machine->s.ch = 0; |
| 95 | } |
| 96 | |
| 97 | static enum utf8_state |
| 98 | utf8_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 Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 171 | struct char_sub { |
| 172 | union utf8_char match; |
| 173 | union utf8_char replace; |
| 174 | }; |
| 175 | /* Set last char_sub match to NULL char */ |
| 176 | typedef struct char_sub *character_set; |
| 177 | |
| 178 | struct char_sub CS_US[] = { |
| 179 | {{{0, }}, {{0, }}} |
| 180 | }; |
| 181 | static struct char_sub CS_UK[] = { |
| 182 | {{{'#', 0, }}, {{0xC2, 0xA3, 0, }}}, |
| 183 | {{{0, }}, {{0, }}} |
| 184 | }; |
| 185 | static 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 | |
| 220 | static void |
| 221 | apply_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 Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 234 | struct key_map { |
| 235 | int sym; |
| 236 | int num; |
| 237 | char escape; |
| 238 | char code; |
| 239 | }; |
| 240 | /* Set last key_sub sym to NULL */ |
| 241 | typedef struct key_map *keyboard_mode; |
| 242 | |
| 243 | static 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 | }; |
| 252 | static 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 | |
| 268 | static int |
| 269 | function_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 */ |
| 295 | static int |
| 296 | apply_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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 315 | struct terminal_color { double r, g, b, a; }; |
| 316 | struct attr { |
| 317 | unsigned char fg, bg; |
| 318 | char a; /* attributes format: |
| 319 | * 76543210 |
| 320 | * ilub */ |
| 321 | char r; /* reserved */ |
| 322 | }; |
| 323 | struct color_scheme { |
| 324 | struct terminal_color palette[16]; |
Kristian Høgsberg | 71eca89 | 2011-01-11 10:13:00 -0500 | [diff] [blame] | 325 | char border; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 326 | struct attr default_attr; |
| 327 | }; |
| 328 | |
| 329 | static void |
| 330 | attr_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øgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 338 | struct terminal { |
| 339 | struct window *window; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 340 | struct display *display; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 341 | union utf8_char *data; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 342 | char *tab_ruler; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 343 | struct attr *data_attr; |
| 344 | struct attr curr_attr; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 345 | uint32_t mode; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 346 | char origin_mode; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 347 | char saved_origin_mode; |
| 348 | struct attr saved_attr; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 349 | union utf8_char last_char; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 350 | int margin_top, margin_bottom; |
Callum Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 351 | character_set cs, g0, g1; |
| 352 | character_set saved_cs, saved_g0, saved_g1; |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 353 | keyboard_mode key_mode; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 354 | int data_pitch, attr_pitch; /* The width in bytes of a line */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 355 | int width, height, start, row, column; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 356 | int saved_row, saved_column; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 357 | int fd, master; |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 358 | GIOChannel *channel; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 359 | uint32_t modifiers; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 360 | char escape[MAX_ESCAPE]; |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 361 | int escape_length; |
Kristian Høgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 362 | int state; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 363 | int qmark_flag; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 364 | struct utf8_state_machine state_machine; |
Kristian Høgsberg | 1584c57 | 2008-12-08 12:59:37 -0500 | [diff] [blame] | 365 | int margin; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 366 | int fullscreen; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 367 | int focused; |
Kristian Høgsberg | 12308a4 | 2009-09-28 13:08:50 -0400 | [diff] [blame] | 368 | struct color_scheme *color_scheme; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 369 | struct terminal_color color_table[256]; |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 370 | cairo_font_extents_t extents; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 371 | cairo_font_face_t *font_normal, *font_bold; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 372 | }; |
| 373 | |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 374 | /* Create default tab stops, every 8 characters */ |
| 375 | static void |
| 376 | terminal_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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 389 | static void |
| 390 | terminal_init(struct terminal *terminal) |
| 391 | { |
| 392 | terminal->curr_attr = terminal->color_scheme->default_attr; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 393 | terminal->origin_mode = 0; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 394 | terminal->mode = MODE_SHOW_CURSOR | |
| 395 | MODE_AUTOREPEAT | |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 396 | MODE_ALT_SENDS_ESC | |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 397 | MODE_AUTOWRAP; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 398 | |
| 399 | terminal->row = 0; |
| 400 | terminal->column = 0; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 401 | |
Callum Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 402 | terminal->g0 = CS_US; |
| 403 | terminal->g1 = CS_US; |
| 404 | terminal->cs = terminal->g0; |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 405 | terminal->key_mode = KM_NORMAL; |
Callum Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 406 | |
| 407 | terminal->saved_g0 = terminal->g0; |
| 408 | terminal->saved_g1 = terminal->g1; |
| 409 | terminal->saved_cs = terminal->cs; |
| 410 | |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 411 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 417 | } |
| 418 | |
| 419 | static void |
| 420 | init_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 Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 444 | static union utf8_char * |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 445 | terminal_get_row(struct terminal *terminal, int row) |
| 446 | { |
| 447 | int index; |
| 448 | |
| 449 | index = (row + terminal->start) % terminal->height; |
| 450 | |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 451 | return &terminal->data[index * terminal->width]; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 452 | } |
| 453 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 454 | static struct attr* |
Kristian Høgsberg | 8c25420 | 2010-12-25 08:58:46 -0500 | [diff] [blame] | 455 | terminal_get_attr_row(struct terminal *terminal, int row) |
| 456 | { |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 457 | int index; |
| 458 | |
| 459 | index = (row + terminal->start) % terminal->height; |
| 460 | |
| 461 | return &terminal->data_attr[index * terminal->width]; |
| 462 | } |
| 463 | |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 464 | struct decoded_attr { |
| 465 | int foreground; |
| 466 | int background; |
| 467 | int bold; |
| 468 | int underline; |
| 469 | }; |
| 470 | |
| 471 | static void |
| 472 | terminal_decode_attr(struct terminal *terminal, int row, int col, |
| 473 | struct decoded_attr *decoded) |
Kristian Høgsberg | 8c25420 | 2010-12-25 08:58:46 -0500 | [diff] [blame] | 474 | { |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 475 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 509 | } |
| 510 | |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 511 | static void |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 512 | terminal_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 | |
| 535 | static void |
| 536 | terminal_scroll_window(struct terminal *terminal, int d) |
| 537 | { |
| 538 | int i; |
| 539 | int window_height; |
| 540 | int from_row, to_row; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 541 | |
| 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 558 | for (i = terminal->margin_top; i < (terminal->margin_top + d); i++) { |
| 559 | memset(terminal_get_row(terminal, i), 0, terminal->data_pitch); |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 560 | attr_init(terminal_get_attr_row(terminal, i), |
| 561 | terminal->curr_attr, terminal->width); |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 562 | } |
| 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 575 | for (i = terminal->margin_bottom - d + 1; i <= terminal->margin_bottom; i++) { |
| 576 | memset(terminal_get_row(terminal, i), 0, terminal->data_pitch); |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 577 | attr_init(terminal_get_attr_row(terminal, i), |
| 578 | terminal->curr_attr, terminal->width); |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 579 | } |
| 580 | } |
| 581 | } |
| 582 | |
| 583 | static void |
| 584 | terminal_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 | |
| 592 | static void |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 593 | terminal_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 | |
| 626 | static void |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 627 | terminal_resize(struct terminal *terminal, int width, int height) |
| 628 | { |
| 629 | size_t size; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 630 | union utf8_char *data; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 631 | struct attr *data_attr; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 632 | char *tab_ruler; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 633 | int data_pitch, attr_pitch; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 634 | int i, l, total_rows, start; |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 635 | struct rectangle allocation; |
Callum Lowcay | a0ee21c | 2011-01-07 19:46:56 +0000 | [diff] [blame] | 636 | struct winsize ws; |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 637 | int32_t pixel_width, pixel_height; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 638 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 639 | if (width < 1) |
| 640 | width = 1; |
| 641 | if (height < 1) |
| 642 | height = 1; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 643 | if (terminal->width == width && terminal->height == height) |
| 644 | return; |
| 645 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 646 | 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 Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 657 | data_pitch = width * sizeof(union utf8_char); |
| 658 | size = data_pitch * height; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 659 | data = malloc(size); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 660 | attr_pitch = width * sizeof(struct attr); |
| 661 | data_attr = malloc(attr_pitch * height); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 662 | tab_ruler = malloc(width); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 663 | memset(data, 0, size); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 664 | memset(tab_ruler, 0, width); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 665 | attr_init(data_attr, terminal->curr_attr, width * height); |
| 666 | if (terminal->data && terminal->data_attr) { |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 667 | if (width > terminal->width) |
| 668 | l = terminal->width; |
| 669 | else |
| 670 | l = width; |
| 671 | |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 672 | if (terminal->height > height) { |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 673 | total_rows = height; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 674 | start = terminal->height - height; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 675 | } else { |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 676 | total_rows = terminal->height; |
| 677 | start = 0; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 678 | } |
| 679 | |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 680 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 684 | memcpy(&data_attr[width * i], |
| 685 | terminal_get_attr_row(terminal, i), |
| 686 | l * sizeof(struct attr)); |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 687 | } |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 688 | |
| 689 | free(terminal->data); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 690 | free(terminal->data_attr); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 691 | free(terminal->tab_ruler); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 692 | } |
| 693 | |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 694 | terminal->data_pitch = data_pitch; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 695 | terminal->attr_pitch = attr_pitch; |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 696 | terminal->margin_bottom = |
| 697 | height - (terminal->height - terminal->margin_bottom); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 698 | terminal->width = width; |
| 699 | terminal->height = height; |
| 700 | terminal->data = data; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 701 | terminal->data_attr = data_attr; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 702 | terminal->tab_ruler = tab_ruler; |
| 703 | terminal_init_tabs(terminal); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 704 | |
Callum Lowcay | a0ee21c | 2011-01-07 19:46:56 +0000 | [diff] [blame] | 705 | /* Update the window size */ |
| 706 | ws.ws_row = terminal->height; |
| 707 | ws.ws_col = terminal->width; |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 708 | window_get_child_allocation(terminal->window, &allocation); |
| 709 | ws.ws_xpixel = allocation.width; |
| 710 | ws.ws_ypixel = allocation.height; |
Callum Lowcay | a0ee21c | 2011-01-07 19:46:56 +0000 | [diff] [blame] | 711 | ioctl(terminal->master, TIOCSWINSZ, &ws); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 712 | } |
| 713 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 714 | struct 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øgsberg | 71eca89 | 2011-01-11 10:13:00 -0500 | [diff] [blame] | 733 | 0, /* black border */ |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 734 | {7, 0, 0, } /* bg:black (0), fg:light gray (7) */ |
| 735 | }; |
Kristian Høgsberg | 12308a4 | 2009-09-28 13:08:50 -0400 | [diff] [blame] | 736 | |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 737 | static void |
Kristian Høgsberg | f106fd5 | 2011-01-11 10:11:39 -0500 | [diff] [blame] | 738 | terminal_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 | |
| 747 | static void |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 748 | terminal_draw_contents(struct terminal *terminal) |
| 749 | { |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 750 | struct rectangle allocation; |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 751 | cairo_t *cr; |
| 752 | cairo_font_extents_t extents; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 753 | int top_margin, side_margin; |
| 754 | int row, col; |
| 755 | union utf8_char *p_row; |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 756 | struct decoded_attr attr; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 757 | int text_x, text_y; |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 758 | cairo_surface_t *surface; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 759 | double d; |
Kristian Høgsberg | 4f50670 | 2010-12-25 16:14:23 -0500 | [diff] [blame^] | 760 | int num_glyphs; |
| 761 | cairo_scaled_font_t *font; |
| 762 | cairo_glyph_t glyphs[256], *g; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 763 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 764 | window_get_child_allocation(terminal->window, &allocation); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 765 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 766 | surface = display_create_surface(terminal->display, &allocation); |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 767 | cr = cairo_create(surface); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 768 | cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); |
Kristian Høgsberg | 71eca89 | 2011-01-11 10:13:00 -0500 | [diff] [blame] | 769 | terminal_set_color(terminal, cr, terminal->color_scheme->border); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 770 | cairo_paint(cr); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 771 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 772 | cairo_set_font_face(cr, terminal->font_normal); |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 773 | cairo_set_font_size(cr, 14); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 774 | |
| 775 | cairo_font_extents(cr, &extents); |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 776 | side_margin = (allocation.width - terminal->width * extents.max_x_advance) / 2; |
| 777 | top_margin = (allocation.height - terminal->height * extents.height) / 2; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 778 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 779 | cairo_set_line_width(cr, 1.0); |
| 780 | |
Kristian Høgsberg | 8c25420 | 2010-12-25 08:58:46 -0500 | [diff] [blame] | 781 | /* 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øgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 786 | terminal_decode_attr(terminal, row, col, &attr); |
Kristian Høgsberg | 8c25420 | 2010-12-25 08:58:46 -0500 | [diff] [blame] | 787 | |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 788 | if (attr.background == terminal->color_scheme->border) |
Kristian Høgsberg | fb266a3 | 2011-01-11 10:15:21 -0500 | [diff] [blame] | 789 | continue; |
| 790 | |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 791 | terminal_set_color(terminal, cr, attr.background); |
Kristian Høgsberg | 8c25420 | 2010-12-25 08:58:46 -0500 | [diff] [blame] | 792 | 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 Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 805 | for (row = 0; row < terminal->height; row++) { |
| 806 | p_row = terminal_get_row(terminal, row); |
| 807 | for (col = 0; col < terminal->width; col++) { |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 808 | /* get the attributes for this character cell */ |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 809 | terminal_decode_attr(terminal, row, col, &attr); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 810 | |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 811 | if (attr.bold) |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 812 | cairo_set_font_face(cr, terminal->font_bold); |
| 813 | else |
| 814 | cairo_set_font_face(cr, terminal->font_normal); |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 815 | terminal_set_color(terminal, cr, attr.foreground); |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 816 | text_x = side_margin + col * extents.max_x_advance; |
| 817 | text_y = top_margin + extents.ascent + row * extents.height; |
Kristian Høgsberg | 01994a5 | 2011-01-11 10:26:04 -0500 | [diff] [blame] | 818 | if (attr.underline) { |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 819 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 821 | cairo_stroke(cr); |
| 822 | } |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 823 | cairo_move_to(cr, text_x, text_y); |
Kristian Høgsberg | 4f50670 | 2010-12-25 16:14:23 -0500 | [diff] [blame^] | 824 | |
| 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 Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 833 | } |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 834 | } |
Kristian Høgsberg | b0b82e2 | 2009-02-21 15:42:25 -0500 | [diff] [blame] | 835 | |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 836 | if ((terminal->mode & MODE_SHOW_CURSOR) && !terminal->focused) { |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 837 | d = 0.5; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 838 | |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 839 | 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øgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 846 | |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 847 | cairo_stroke(cr); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 848 | } |
Kristian Høgsberg | b0b82e2 | 2009-02-21 15:42:25 -0500 | [diff] [blame] | 849 | |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 850 | cairo_destroy(cr); |
| 851 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 852 | window_copy_surface(terminal->window, &allocation, surface); |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 853 | |
| 854 | cairo_surface_destroy(surface); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 855 | } |
| 856 | |
| 857 | static void |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 858 | resize_handler(struct window *window, |
| 859 | int32_t pixel_width, int32_t pixel_height, void *data) |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 860 | { |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 861 | struct terminal *terminal = data; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 862 | int32_t width, height; |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 863 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 864 | width = (pixel_width - 2 * terminal->margin) / |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 865 | (int32_t) terminal->extents.max_x_advance; |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 866 | height = (pixel_height - 2 * terminal->margin) / |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 867 | (int32_t) terminal->extents.height; |
Tiago Vignatti | 5fd89d2 | 2011-01-10 19:30:04 +0200 | [diff] [blame] | 868 | |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 869 | terminal_resize(terminal, width, height); |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 870 | } |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 871 | |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 872 | static void |
| 873 | terminal_draw(struct terminal *terminal) |
| 874 | { |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 875 | window_draw(terminal->window); |
| 876 | terminal_draw_contents(terminal); |
Kristian Høgsberg | 9d69f8e | 2010-09-03 14:46:38 -0400 | [diff] [blame] | 877 | window_flush(terminal->window); |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 878 | } |
| 879 | |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 880 | static void |
| 881 | redraw_handler(struct window *window, void *data) |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 882 | { |
| 883 | struct terminal *terminal = data; |
| 884 | |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 885 | terminal_draw(terminal); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 886 | } |
| 887 | |
Kristian Høgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 888 | #define STATE_NORMAL 0 |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 889 | #define STATE_ESCAPE 1 |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 890 | #define STATE_ESCAPE_SPECIAL 2 |
| 891 | #define STATE_ESCAPE_CSI 3 |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 892 | |
| 893 | static void |
| 894 | terminal_data(struct terminal *terminal, const char *data, size_t length); |
Kristian Høgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 895 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 896 | static void |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 897 | handle_char(struct terminal *terminal, union utf8_char utf8); |
| 898 | |
| 899 | static void |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 900 | handle_sgr(struct terminal *terminal, int code); |
| 901 | |
| 902 | static void |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 903 | handle_term_parameter(struct terminal *terminal, int code, int sr) |
| 904 | { |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 905 | int i; |
| 906 | |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 907 | if (terminal->qmark_flag) { |
| 908 | switch(code) { |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 909 | case 1: /* DECCKM */ |
| 910 | if (sr) terminal->key_mode = KM_APPLICATION; |
| 911 | else terminal->key_mode = KM_NORMAL; |
| 912 | break; |
Callum Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 913 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 919 | 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 938 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 946 | 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 Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 958 | 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 966 | default: |
| 967 | fprintf(stderr, "Unknown parameter: ?%d\n", code); |
| 968 | break; |
| 969 | } |
| 970 | } else { |
| 971 | switch(code) { |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 972 | case 4: /* IRM */ |
| 973 | if (sr) terminal->mode |= MODE_IRM; |
| 974 | else terminal->mode &= ~MODE_IRM; |
| 975 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 976 | case 20: /* LNM */ |
| 977 | if (sr) terminal->mode |= MODE_LF_NEWLINE; |
| 978 | else terminal->mode &= ~MODE_LF_NEWLINE; |
| 979 | break; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 980 | default: |
| 981 | fprintf(stderr, "Unknown parameter: %d\n", code); |
| 982 | break; |
| 983 | } |
| 984 | } |
| 985 | } |
| 986 | |
| 987 | static void |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 988 | handle_escape(struct terminal *terminal) |
| 989 | { |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 990 | union utf8_char *row; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 991 | struct attr *attr_row; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 992 | char *p; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 993 | int i, count, x, y, top, bottom; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 994 | int args[10], set[10] = { 0, }; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 995 | char response[MAX_RESPONSE] = {0, }; |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 996 | |
| 997 | terminal->escape[terminal->escape_length++] = '\0'; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 998 | i = 0; |
| 999 | p = &terminal->escape[2]; |
| 1000 | while ((isdigit(*p) || *p == ';') && i < 10) { |
| 1001 | if (*p == ';') { |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1002 | if (!set[i]) { |
| 1003 | args[i] = 0; |
| 1004 | set[i] = 1; |
| 1005 | } |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1006 | p++; |
| 1007 | i++; |
| 1008 | } else { |
| 1009 | args[i] = strtol(p, &p, 10); |
| 1010 | set[i] = 1; |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1011 | } |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1012 | } |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1013 | |
| 1014 | switch (*p) { |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1015 | case '@': /* ICH */ |
| 1016 | count = set[0] ? args[0] : 1; |
| 1017 | if (count == 0) count = 1; |
| 1018 | terminal_shift_line(terminal, count); |
| 1019 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1020 | case 'A': /* CUU */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1021 | count = set[0] ? args[0] : 1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1022 | if (count == 0) count = 1; |
| 1023 | if (terminal->row - count >= terminal->margin_top) |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1024 | terminal->row -= count; |
| 1025 | else |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1026 | terminal->row = terminal->margin_top; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1027 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1028 | case 'B': /* CUD */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1029 | count = set[0] ? args[0] : 1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1030 | if (count == 0) count = 1; |
| 1031 | if (terminal->row + count <= terminal->margin_bottom) |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1032 | terminal->row += count; |
| 1033 | else |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1034 | terminal->row = terminal->margin_bottom; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1035 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1036 | case 'C': /* CUF */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1037 | count = set[0] ? args[0] : 1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1038 | if (count == 0) count = 1; |
| 1039 | if ((terminal->column + count) < terminal->width) |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1040 | terminal->column += count; |
| 1041 | else |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1042 | terminal->column = terminal->width - 1; |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1043 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1044 | case 'D': /* CUB */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1045 | count = set[0] ? args[0] : 1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1046 | if (count == 0) count = 1; |
| 1047 | if ((terminal->column - count) >= 0) |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1048 | terminal->column -= count; |
| 1049 | else |
| 1050 | terminal->column = 0; |
| 1051 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1052 | 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øgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1103 | row = terminal_get_row(terminal, terminal->row); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1104 | attr_row = terminal_get_attr_row(terminal, terminal->row); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1105 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1132 | } |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1133 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1134 | case 'K': /* EL */ |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1135 | row = terminal_get_row(terminal, terminal->row); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1136 | attr_row = terminal_get_attr_row(terminal, terminal->row); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1137 | 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øgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1149 | break; |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1150 | 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1187 | 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 Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1193 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1203 | 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 Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1227 | write(terminal->master, "\e[?6c", 5); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1228 | 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 Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1242 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1252 | 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øgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1272 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1273 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1284 | break; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1285 | 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øgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1310 | } |
| 1311 | break; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1312 | 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øgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1320 | default: |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1321 | fprintf(stderr, "Unknown CSI escape: %c\n", *p); |
Kristian Høgsberg | dbd5464 | 2008-12-08 22:22:25 -0500 | [diff] [blame] | 1322 | break; |
| 1323 | } |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1324 | } |
| 1325 | |
| 1326 | static void |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1327 | handle_non_csi_escape(struct terminal *terminal, char code) |
| 1328 | { |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1329 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1347 | 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 Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 1358 | terminal->saved_cs = terminal->cs; |
| 1359 | terminal->saved_g0 = terminal->g0; |
| 1360 | terminal->saved_g1 = terminal->g1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1361 | 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 Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 1367 | terminal->cs = terminal->saved_cs; |
| 1368 | terminal->g0 = terminal->saved_g0; |
| 1369 | terminal->g1 = terminal->saved_g1; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1370 | break; |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 1371 | case '=': /* DECPAM */ |
| 1372 | terminal->key_mode = KM_APPLICATION; |
| 1373 | break; |
| 1374 | case '>': /* DECPNM */ |
| 1375 | terminal->key_mode = KM_NORMAL; |
| 1376 | break; |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1377 | default: |
| 1378 | fprintf(stderr, "Unknown escape code: %c\n", code); |
| 1379 | break; |
| 1380 | } |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1381 | } |
| 1382 | |
| 1383 | static void |
| 1384 | handle_special_escape(struct terminal *terminal, char special, char code) |
| 1385 | { |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1386 | 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 Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 1402 | } 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1426 | } else { |
| 1427 | fprintf(stderr, "Unknown special escape %c%c\n", special, code); |
| 1428 | } |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1429 | } |
| 1430 | |
| 1431 | static void |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1432 | handle_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 Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1493 | /* Returns 1 if c was special, otherwise 0 */ |
| 1494 | static int |
| 1495 | handle_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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1508 | if (terminal->mode & MODE_LF_NEWLINE) { |
| 1509 | terminal->column = 0; |
| 1510 | } |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1511 | /* fallthrough */ |
| 1512 | case '\v': |
| 1513 | case '\f': |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1514 | terminal->row++; |
| 1515 | if(terminal->row > terminal->margin_bottom) { |
| 1516 | terminal->row = terminal->margin_bottom; |
| 1517 | terminal_scroll(terminal, +1); |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1518 | } |
| 1519 | |
| 1520 | break; |
| 1521 | case '\t': |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1522 | while (terminal->column < terminal->width) { |
| 1523 | if (terminal->tab_ruler[terminal->column]) break; |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1524 | if (terminal->mode & MODE_IRM) |
| 1525 | terminal_shift_line(terminal, +1); |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1526 | 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 Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1535 | break; |
| 1536 | case '\b': |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1537 | if (terminal->column >= terminal->width) { |
| 1538 | terminal->column = terminal->width - 2; |
| 1539 | } else if (terminal->column > 0) { |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1540 | terminal->column--; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1541 | } 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 Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1550 | break; |
| 1551 | case '\a': |
| 1552 | /* Bell */ |
| 1553 | break; |
Callum Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 1554 | case '\x0E': /* SO */ |
| 1555 | terminal->cs = terminal->g1; |
| 1556 | break; |
| 1557 | case '\x0F': /* SI */ |
| 1558 | terminal->cs = terminal->g0; |
| 1559 | break; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1560 | default: |
| 1561 | return 0; |
| 1562 | } |
| 1563 | |
| 1564 | return 1; |
| 1565 | } |
| 1566 | |
| 1567 | static void |
| 1568 | handle_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 Lowcay | 256e72f | 2011-01-07 19:47:01 +0000 | [diff] [blame] | 1574 | |
| 1575 | apply_char_set(terminal->cs, &utf8); |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1576 | |
| 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1592 | 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 Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1603 | |
| 1604 | row = terminal_get_row(terminal, terminal->row); |
| 1605 | attr_row = terminal_get_attr_row(terminal, terminal->row); |
| 1606 | |
Callum Lowcay | 69e9658 | 2011-01-07 19:47:00 +0000 | [diff] [blame] | 1607 | if (terminal->mode & MODE_IRM) |
| 1608 | terminal_shift_line(terminal, +1); |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1609 | 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 Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1616 | static void |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1617 | terminal_data(struct terminal *terminal, const char *data, size_t length) |
| 1618 | { |
| 1619 | int i; |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 1620 | union utf8_char utf8; |
| 1621 | enum utf8_state parser_state; |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1622 | |
| 1623 | for (i = 0; i < length; i++) { |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 1624 | 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 Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1641 | /* assume escape codes never use non-ASCII characters */ |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1642 | if (terminal->state == STATE_ESCAPE) { |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 1643 | terminal->escape[terminal->escape_length++] = utf8.byte[0]; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1644 | 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øgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 1653 | terminal->state = STATE_NORMAL; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1654 | handle_non_csi_escape(terminal, utf8.byte[0]); |
| 1655 | continue; |
Kristian Høgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1656 | } |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1657 | } 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øgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1681 | terminal->state = STATE_NORMAL; |
| 1682 | handle_escape(terminal); |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1683 | continue; |
| 1684 | } else { |
| 1685 | continue; |
| 1686 | } |
Kristian Høgsberg | f04e838 | 2008-12-08 00:07:49 -0500 | [diff] [blame] | 1687 | } |
| 1688 | |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1689 | /* 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øgsberg | 17809b1 | 2008-12-08 12:20:40 -0500 | [diff] [blame] | 1692 | terminal->state = STATE_ESCAPE; |
| 1693 | terminal->escape[0] = '\e'; |
| 1694 | terminal->escape_length = 1; |
Callum Lowcay | b8609ad | 2011-01-07 19:46:57 +0000 | [diff] [blame] | 1695 | terminal->qmark_flag = 0; |
| 1696 | } else { |
| 1697 | handle_char(terminal, utf8); |
| 1698 | } /* if */ |
| 1699 | } /* for */ |
Kristian Høgsberg | 721f09f | 2008-12-08 11:13:26 -0500 | [diff] [blame] | 1700 | |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 1701 | window_schedule_redraw(terminal->window); |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1702 | } |
| 1703 | |
| 1704 | static void |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1705 | key_handler(struct window *window, uint32_t key, uint32_t sym, |
Kristian Høgsberg | 5544491 | 2009-02-21 14:31:09 -0500 | [diff] [blame] | 1706 | uint32_t state, uint32_t modifiers, void *data) |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1707 | { |
| 1708 | struct terminal *terminal = data; |
Callum Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1709 | char ch[MAX_RESPONSE]; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1710 | int len = 0; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1711 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1712 | switch (sym) { |
| 1713 | case XK_F11: |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1714 | if (!state) |
| 1715 | break; |
| 1716 | terminal->fullscreen ^= 1; |
| 1717 | window_set_fullscreen(window, terminal->fullscreen); |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 1718 | window_schedule_redraw(terminal->window); |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1719 | break; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1720 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1721 | case XK_BackSpace: |
| 1722 | case XK_Tab: |
| 1723 | case XK_Linefeed: |
| 1724 | case XK_Clear: |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1725 | 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 Lowcay | 8e57dd5 | 2011-01-07 19:46:59 +0000 | [diff] [blame] | 1732 | 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øgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1741 | 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 Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 1749 | 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øgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1798 | default: |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 1799 | /* 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øgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1816 | ch[len++] = 0x1b; |
Callum Lowcay | 7e08e90 | 2011-01-07 19:47:02 +0000 | [diff] [blame] | 1817 | } else if (modifiers & WINDOW_MODIFIER_ALT) { |
| 1818 | sym = sym | 0x80; |
| 1819 | } |
| 1820 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1821 | if (sym < 256) |
| 1822 | ch[len++] = sym; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1823 | break; |
| 1824 | } |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1825 | |
| 1826 | if (state && len > 0) |
| 1827 | write(terminal->master, ch, len); |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1828 | } |
| 1829 | |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 1830 | static void |
| 1831 | keyboard_focus_handler(struct window *window, |
Kristian Høgsberg | 43788b1 | 2010-07-28 23:50:12 -0400 | [diff] [blame] | 1832 | struct input *device, void *data) |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 1833 | { |
| 1834 | struct terminal *terminal = data; |
| 1835 | |
| 1836 | terminal->focused = (device != NULL); |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 1837 | window_schedule_redraw(terminal->window); |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 1838 | } |
| 1839 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1840 | static struct terminal * |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1841 | terminal_create(struct display *display, int fullscreen) |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1842 | { |
| 1843 | struct terminal *terminal; |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 1844 | cairo_surface_t *surface; |
| 1845 | cairo_t *cr; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1846 | |
| 1847 | terminal = malloc(sizeof *terminal); |
| 1848 | if (terminal == NULL) |
| 1849 | return terminal; |
| 1850 | |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1851 | memset(terminal, 0, sizeof *terminal); |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1852 | terminal->fullscreen = fullscreen; |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1853 | terminal->color_scheme = &DEFAULT_COLORS; |
| 1854 | terminal_init(terminal); |
Callum Lowcay | bbeac60 | 2011-01-07 19:46:58 +0000 | [diff] [blame] | 1855 | terminal->margin_top = 0; |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 1856 | terminal->margin_bottom = -1; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1857 | terminal->window = window_create(display, "Wayland Terminal", |
Kristian Høgsberg | 82da52b | 2010-12-17 09:53:12 -0500 | [diff] [blame] | 1858 | 500, 400); |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 1859 | |
| 1860 | init_state_machine(&terminal->state_machine); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1861 | init_color_table(terminal); |
Callum Lowcay | 15bdc5d | 2011-01-07 19:46:54 +0000 | [diff] [blame] | 1862 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1863 | terminal->display = display; |
Kristian Høgsberg | 1584c57 | 2008-12-08 12:59:37 -0500 | [diff] [blame] | 1864 | terminal->margin = 5; |
Kristian Høgsberg | 44e3c5e | 2008-12-07 21:51:58 -0500 | [diff] [blame] | 1865 | |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1866 | window_set_fullscreen(terminal->window, terminal->fullscreen); |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 1867 | window_set_user_data(terminal->window, terminal); |
| 1868 | window_set_redraw_handler(terminal->window, redraw_handler); |
Kristian Høgsberg | da846ca | 2011-01-11 10:00:52 -0500 | [diff] [blame] | 1869 | window_set_resize_handler(terminal->window, resize_handler); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 1870 | |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 1871 | window_set_key_handler(terminal->window, key_handler); |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 1872 | window_set_keyboard_focus_handler(terminal->window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 1873 | keyboard_focus_handler); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1874 | |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 1875 | surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0); |
| 1876 | cr = cairo_create(surface); |
Callum Lowcay | 30eeae5 | 2011-01-07 19:46:55 +0000 | [diff] [blame] | 1877 | 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øgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 1886 | cairo_set_font_size(cr, 14); |
| 1887 | cairo_font_extents(cr, &terminal->extents); |
| 1888 | cairo_destroy(cr); |
| 1889 | cairo_surface_destroy(surface); |
| 1890 | |
Callum Lowcay | a0ee21c | 2011-01-07 19:46:56 +0000 | [diff] [blame] | 1891 | terminal_resize(terminal, 80, 24); |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 1892 | terminal_draw(terminal); |
| 1893 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1894 | return terminal; |
| 1895 | } |
| 1896 | |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1897 | static gboolean |
| 1898 | io_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øgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1909 | |
| 1910 | terminal_data(terminal, buffer, bytes_read); |
| 1911 | |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1912 | return TRUE; |
| 1913 | } |
| 1914 | |
| 1915 | static int |
| 1916 | terminal_run(struct terminal *terminal, const char *path) |
| 1917 | { |
Kristian Høgsberg | f0c7b20 | 2008-12-12 13:39:03 -0500 | [diff] [blame] | 1918 | int master; |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1919 | pid_t pid; |
| 1920 | |
| 1921 | pid = forkpty(&master, NULL, NULL, NULL); |
| 1922 | if (pid == 0) { |
Callum Lowcay | 86653ed | 2011-01-07 19:47:03 +0000 | [diff] [blame] | 1923 | setenv("TERM", "xterm-256color", 1); |
| 1924 | setenv("COLORTERM", "xterm-256color", 1); |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1925 | if (execl(path, path, NULL)) { |
| 1926 | printf("exec failed: %m\n"); |
| 1927 | exit(EXIT_FAILURE); |
| 1928 | } |
Kristian Høgsberg | f0c7b20 | 2008-12-12 13:39:03 -0500 | [diff] [blame] | 1929 | } else if (pid < 0) { |
| 1930 | fprintf(stderr, "failed to fork and create pty (%m).\n"); |
| 1931 | return -1; |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1932 | } |
| 1933 | |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 1934 | terminal->master = master; |
Kristian Høgsberg | 269d6e3 | 2008-12-07 23:17:31 -0500 | [diff] [blame] | 1935 | 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øgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1943 | static 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øgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1949 | int main(int argc, char *argv[]) |
| 1950 | { |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1951 | struct display *d; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1952 | struct terminal *terminal; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 1953 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1954 | d = display_create(&argc, &argv, option_entries); |
Yuval Fledel | e9f5e36 | 2010-11-22 21:34:19 +0200 | [diff] [blame] | 1955 | if (d == NULL) { |
| 1956 | fprintf(stderr, "failed to create display: %m\n"); |
| 1957 | return -1; |
| 1958 | } |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1959 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1960 | terminal = terminal_create(d, option_fullscreen); |
Kristian Høgsberg | f0c7b20 | 2008-12-12 13:39:03 -0500 | [diff] [blame] | 1961 | if (terminal_run(terminal, "/bin/bash")) |
| 1962 | exit(EXIT_FAILURE); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1963 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1964 | display_run(d); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1965 | |
| 1966 | return 0; |
| 1967 | } |