Terminal.cpp 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152
  1. #include "Terminal.h"
  2. #include "XtermColors.h"
  3. #include <AK/AKString.h>
  4. #include <AK/StdLibExtras.h>
  5. #include <AK/StringBuilder.h>
  6. #include <Kernel/KeyCode.h>
  7. #include <LibGUI/GApplication.h>
  8. #include <LibGUI/GPainter.h>
  9. #include <LibGUI/GWindow.h>
  10. #include <SharedGraphics/Font.h>
  11. #include <errno.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <sys/ioctl.h>
  16. #include <unistd.h>
  17. //#define TERMINAL_DEBUG
  18. byte Terminal::Attribute::default_foreground_color = 7;
  19. byte Terminal::Attribute::default_background_color = 0;
  20. Terminal::Terminal(int ptm_fd, RetainPtr<CConfigFile> config)
  21. : m_ptm_fd(ptm_fd)
  22. , m_notifier(ptm_fd, CNotifier::Read)
  23. , m_config(config)
  24. {
  25. set_frame_shape(FrameShape::Container);
  26. set_frame_shadow(FrameShadow::Sunken);
  27. set_frame_thickness(2);
  28. dbgprintf("Terminal: Load config file from %s\n", m_config->file_name().characters());
  29. m_cursor_blink_timer.set_interval(m_config->read_num_entry("Text",
  30. "CursorBlinkInterval",
  31. 500));
  32. m_cursor_blink_timer.on_timeout = [this] {
  33. m_cursor_blink_state = !m_cursor_blink_state;
  34. update_cursor();
  35. };
  36. auto font_entry = m_config->read_entry("Text", "Font", "default");
  37. if (font_entry == "default")
  38. set_font(Font::default_fixed_width_font());
  39. else
  40. set_font(Font::load_from_file(font_entry));
  41. m_notifier.on_ready_to_read = [this] {
  42. byte buffer[BUFSIZ];
  43. ssize_t nread = read(m_ptm_fd, buffer, sizeof(buffer));
  44. if (nread < 0) {
  45. dbgprintf("Terminal read error: %s\n", strerror(errno));
  46. perror("read(ptm)");
  47. GApplication::the().quit(1);
  48. return;
  49. }
  50. if (nread == 0) {
  51. dbgprintf("Terminal: EOF on master pty, closing.\n");
  52. GApplication::the().quit(0);
  53. return;
  54. }
  55. for (ssize_t i = 0; i < nread; ++i)
  56. on_char(buffer[i]);
  57. flush_dirty_lines();
  58. };
  59. m_line_height = font().glyph_height() + m_line_spacing;
  60. set_size(m_config->read_num_entry("Window", "Width", 80),
  61. m_config->read_num_entry("Window", "Height", 25));
  62. }
  63. Terminal::Line::Line(word length)
  64. {
  65. set_length(length);
  66. }
  67. Terminal::Line::~Line()
  68. {
  69. delete[] characters;
  70. delete[] attributes;
  71. }
  72. void Terminal::Line::set_length(word new_length)
  73. {
  74. if (m_length == new_length)
  75. return;
  76. auto* new_characters = new byte[new_length];
  77. auto* new_attributes = new Attribute[new_length];
  78. memset(new_characters, ' ', new_length);
  79. delete[] characters;
  80. delete[] attributes;
  81. characters = new_characters;
  82. attributes = new_attributes;
  83. m_length = new_length;
  84. }
  85. void Terminal::Line::clear(Attribute attribute)
  86. {
  87. if (dirty) {
  88. memset(characters, ' ', m_length);
  89. for (word i = 0; i < m_length; ++i)
  90. attributes[i] = attribute;
  91. return;
  92. }
  93. for (unsigned i = 0; i < m_length; ++i) {
  94. if (characters[i] != ' ')
  95. dirty = true;
  96. characters[i] = ' ';
  97. }
  98. for (unsigned i = 0; i < m_length; ++i) {
  99. if (attributes[i] != attribute)
  100. dirty = true;
  101. attributes[i] = attribute;
  102. }
  103. }
  104. Terminal::~Terminal()
  105. {
  106. }
  107. void Terminal::clear()
  108. {
  109. for (size_t i = 0; i < rows(); ++i)
  110. line(i).clear(m_current_attribute);
  111. set_cursor(0, 0);
  112. }
  113. inline bool is_valid_parameter_character(byte ch)
  114. {
  115. return ch >= 0x30 && ch <= 0x3f;
  116. }
  117. inline bool is_valid_intermediate_character(byte ch)
  118. {
  119. return ch >= 0x20 && ch <= 0x2f;
  120. }
  121. inline bool is_valid_final_character(byte ch)
  122. {
  123. return ch >= 0x40 && ch <= 0x7e;
  124. }
  125. static inline Color lookup_color(unsigned color)
  126. {
  127. return Color::from_rgb(xterm_colors[color]);
  128. }
  129. void Terminal::escape$h_l(bool should_set, bool question_param, const ParamVector& params)
  130. {
  131. int mode = 2;
  132. if (params.size() > 0) {
  133. mode = params[0];
  134. }
  135. if (!question_param) {
  136. switch (mode) {
  137. // FIXME: implement *something* for this
  138. default:
  139. unimplemented_escape();
  140. break;
  141. }
  142. } else {
  143. switch (mode) {
  144. case 25:
  145. // Hide cursor command, but doesn't need to be run (for now, because
  146. // we don't do inverse control codes anyways)
  147. if (should_set)
  148. dbgprintf("Terminal: Hide Cursor escapecode recieved. Not needed: ignored.\n");
  149. else
  150. dbgprintf("Terminal: Show Cursor escapecode recieved. Not needed: ignored.\n");
  151. break;
  152. default:
  153. break;
  154. }
  155. }
  156. }
  157. void Terminal::escape$m(const ParamVector& params)
  158. {
  159. if (params.is_empty()) {
  160. m_current_attribute.reset();
  161. return;
  162. }
  163. if (params.size() == 3 && params[1] == 5) {
  164. if (params[0] == 38) {
  165. m_current_attribute.foreground_color = params[2];
  166. return;
  167. } else if (params[0] == 48) {
  168. m_current_attribute.background_color = params[2];
  169. return;
  170. }
  171. }
  172. for (auto param : params) {
  173. switch (param) {
  174. case 0:
  175. // Reset
  176. m_current_attribute.reset();
  177. break;
  178. case 1:
  179. m_current_attribute.flags |= Attribute::Bold;
  180. break;
  181. case 3:
  182. m_current_attribute.flags |= Attribute::Italic;
  183. break;
  184. case 4:
  185. m_current_attribute.flags |= Attribute::Underline;
  186. break;
  187. case 5:
  188. m_current_attribute.flags |= Attribute::Blink;
  189. break;
  190. case 7:
  191. m_current_attribute.flags |= Attribute::Negative;
  192. break;
  193. case 22:
  194. m_current_attribute.flags &= ~Attribute::Bold;
  195. break;
  196. case 23:
  197. m_current_attribute.flags &= ~Attribute::Italic;
  198. break;
  199. case 24:
  200. m_current_attribute.flags &= ~Attribute::Underline;
  201. break;
  202. case 25:
  203. m_current_attribute.flags &= ~Attribute::Blink;
  204. break;
  205. case 27:
  206. m_current_attribute.flags &= ~Attribute::Negative;
  207. break;
  208. case 30:
  209. case 31:
  210. case 32:
  211. case 33:
  212. case 34:
  213. case 35:
  214. case 36:
  215. case 37:
  216. // Foreground color
  217. if (m_current_attribute.flags & Attribute::Bold)
  218. param += 8;
  219. m_current_attribute.foreground_color = param - 30;
  220. break;
  221. case 39:
  222. // reset foreground
  223. m_current_attribute.foreground_color = Attribute::default_foreground_color;
  224. break;
  225. case 40:
  226. case 41:
  227. case 42:
  228. case 43:
  229. case 44:
  230. case 45:
  231. case 46:
  232. case 47:
  233. // Background color
  234. if (m_current_attribute.flags & Attribute::Bold)
  235. param += 8;
  236. m_current_attribute.background_color = param - 40;
  237. break;
  238. case 49:
  239. // reset background
  240. m_current_attribute.background_color = Attribute::default_background_color;
  241. break;
  242. default:
  243. dbgprintf("FIXME: escape$m: p: %u\n", param);
  244. }
  245. }
  246. }
  247. void Terminal::escape$s(const ParamVector&)
  248. {
  249. m_saved_cursor_row = m_cursor_row;
  250. m_saved_cursor_column = m_cursor_column;
  251. }
  252. void Terminal::escape$u(const ParamVector&)
  253. {
  254. set_cursor(m_saved_cursor_row, m_saved_cursor_column);
  255. }
  256. void Terminal::escape$t(const ParamVector& params)
  257. {
  258. if (params.size() < 1)
  259. return;
  260. dbgprintf("FIXME: escape$t: Ps: %u (param count: %d)\n", params[0], params.size());
  261. }
  262. void Terminal::escape$r(const ParamVector& params)
  263. {
  264. unsigned top = 1;
  265. unsigned bottom = m_rows;
  266. if (params.size() >= 1)
  267. top = params[0];
  268. if (params.size() >= 2)
  269. bottom = params[1];
  270. if ((bottom - top) < 2 || bottom > m_rows || top < 0) {
  271. dbgprintf("Error: escape$r: scrolling region invalid: %u-%u\n", top, bottom);
  272. return;
  273. }
  274. m_scroll_region_top = top - 1;
  275. m_scroll_region_bottom = bottom - 1;
  276. set_cursor(0, 0);
  277. }
  278. void Terminal::escape$H(const ParamVector& params)
  279. {
  280. unsigned row = 1;
  281. unsigned col = 1;
  282. if (params.size() >= 1)
  283. row = params[0];
  284. if (params.size() >= 2)
  285. col = params[1];
  286. set_cursor(row - 1, col - 1);
  287. }
  288. void Terminal::escape$A(const ParamVector& params)
  289. {
  290. int num = 1;
  291. if (params.size() >= 1)
  292. num = params[0];
  293. if (num == 0)
  294. num = 1;
  295. int new_row = (int)m_cursor_row - num;
  296. if (new_row < 0)
  297. new_row = 0;
  298. set_cursor(new_row, m_cursor_column);
  299. }
  300. void Terminal::escape$B(const ParamVector& params)
  301. {
  302. int num = 1;
  303. if (params.size() >= 1)
  304. num = params[0];
  305. if (num == 0)
  306. num = 1;
  307. int new_row = (int)m_cursor_row + num;
  308. if (new_row >= m_rows)
  309. new_row = m_rows - 1;
  310. set_cursor(new_row, m_cursor_column);
  311. }
  312. void Terminal::escape$C(const ParamVector& params)
  313. {
  314. int num = 1;
  315. if (params.size() >= 1)
  316. num = params[0];
  317. if (num == 0)
  318. num = 1;
  319. int new_column = (int)m_cursor_column + num;
  320. if (new_column >= m_columns)
  321. new_column = m_columns - 1;
  322. set_cursor(m_cursor_row, new_column);
  323. }
  324. void Terminal::escape$D(const ParamVector& params)
  325. {
  326. int num = 1;
  327. if (params.size() >= 1)
  328. num = params[0];
  329. if (num == 0)
  330. num = 1;
  331. int new_column = (int)m_cursor_column - num;
  332. if (new_column < 0)
  333. new_column = 0;
  334. set_cursor(m_cursor_row, new_column);
  335. }
  336. void Terminal::escape$G(const ParamVector& params)
  337. {
  338. int new_column = 1;
  339. if (params.size() >= 1)
  340. new_column = params[0] - 1;
  341. if (new_column < 0)
  342. new_column = 0;
  343. set_cursor(m_cursor_row, new_column);
  344. }
  345. void Terminal::escape$b(const ParamVector& params)
  346. {
  347. if (params.size() < 1)
  348. return;
  349. for (unsigned i = 0; i < params[0]; ++i)
  350. put_character_at(m_cursor_row, m_cursor_column++, m_last_char);
  351. }
  352. void Terminal::escape$d(const ParamVector& params)
  353. {
  354. int new_row = 1;
  355. if (params.size() >= 1)
  356. new_row = params[0] - 1;
  357. if (new_row < 0)
  358. new_row = 0;
  359. set_cursor(new_row, m_cursor_column);
  360. }
  361. void Terminal::escape$X(const ParamVector& params)
  362. {
  363. // Erase characters (without moving cursor)
  364. int num = 1;
  365. if (params.size() >= 1)
  366. num = params[0];
  367. if (num == 0)
  368. num = 1;
  369. // Clear from cursor to end of line.
  370. for (int i = m_cursor_column; i < num; ++i) {
  371. put_character_at(m_cursor_row, i, ' ');
  372. }
  373. }
  374. void Terminal::escape$K(const ParamVector& params)
  375. {
  376. int mode = 0;
  377. if (params.size() >= 1)
  378. mode = params[0];
  379. switch (mode) {
  380. case 0:
  381. // Clear from cursor to end of line.
  382. for (int i = m_cursor_column; i < m_columns; ++i) {
  383. put_character_at(m_cursor_row, i, ' ');
  384. }
  385. break;
  386. case 1:
  387. // Clear from cursor to beginning of line.
  388. for (int i = 0; i < m_cursor_column; ++i) {
  389. put_character_at(m_cursor_row, i, ' ');
  390. }
  391. break;
  392. case 2:
  393. // Clear the complete line
  394. for (int i = 0; i < m_columns; ++i) {
  395. put_character_at(m_cursor_row, i, ' ');
  396. }
  397. break;
  398. default:
  399. unimplemented_escape();
  400. break;
  401. }
  402. }
  403. void Terminal::escape$J(const ParamVector& params)
  404. {
  405. int mode = 0;
  406. if (params.size() >= 1)
  407. mode = params[0];
  408. switch (mode) {
  409. case 0:
  410. // Clear from cursor to end of screen.
  411. for (int i = m_cursor_column; i < m_columns; ++i)
  412. put_character_at(m_cursor_row, i, ' ');
  413. for (int row = m_cursor_row + 1; row < m_rows; ++row) {
  414. for (int column = 0; column < m_columns; ++column) {
  415. put_character_at(row, column, ' ');
  416. }
  417. }
  418. break;
  419. case 1:
  420. /// Clear from cursor to beginning of screen
  421. for (int i = m_cursor_column - 1; i >= 0; --i)
  422. put_character_at(m_cursor_row, i, ' ');
  423. for (int row = m_cursor_row - 1; row >= 0; --row) {
  424. for (int column = 0; column < m_columns; ++column) {
  425. put_character_at(row, column, ' ');
  426. }
  427. }
  428. break;
  429. case 2:
  430. clear();
  431. break;
  432. case 3:
  433. // FIXME: <esc>[3J should also clear the scrollback buffer.
  434. clear();
  435. break;
  436. default:
  437. unimplemented_escape();
  438. break;
  439. }
  440. }
  441. void Terminal::escape$S(const ParamVector& params)
  442. {
  443. int count = 1;
  444. if (params.size() >= 1)
  445. count = params[0];
  446. for (word i = 0; i < count; i++)
  447. scroll_up();
  448. }
  449. void Terminal::escape$T(const ParamVector& params)
  450. {
  451. int count = 1;
  452. if (params.size() >= 1)
  453. count = params[0];
  454. for (word i = 0; i < count; i++)
  455. scroll_down();
  456. }
  457. void Terminal::escape$L(const ParamVector& params)
  458. {
  459. int count = 1;
  460. if (params.size() >= 1)
  461. count = params[0];
  462. invalidate_cursor();
  463. for (; count > 0; --count) {
  464. m_lines.insert(m_cursor_row + m_scroll_region_top, make<Line>(m_columns));
  465. if (m_scroll_region_bottom + 1 < m_lines.size())
  466. m_lines.remove(m_scroll_region_bottom + 1);
  467. else
  468. m_lines.remove(m_lines.size() - 1);
  469. }
  470. m_need_full_flush = true;
  471. }
  472. void Terminal::escape$M(const ParamVector& params)
  473. {
  474. int count = 1;
  475. if (params.size() >= 1)
  476. count = params[0];
  477. if (count == 1 && m_cursor_row == 0) {
  478. scroll_up();
  479. return;
  480. }
  481. int max_count = m_rows - (m_scroll_region_top + m_cursor_row);
  482. count = min(count, max_count);
  483. for (int c = count; c > 0; --c) {
  484. m_lines.remove(m_cursor_row + m_scroll_region_top);
  485. if (m_scroll_region_bottom < m_lines.size())
  486. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  487. else
  488. m_lines.append(make<Line>(m_columns));
  489. }
  490. }
  491. void Terminal::escape$P(const ParamVector& params)
  492. {
  493. int num = 1;
  494. if (params.size() >= 1)
  495. num = params[0];
  496. if (num == 0)
  497. num = 1;
  498. auto& line = this->line(m_cursor_row);
  499. // Move n characters of line to the left
  500. for (int i = m_cursor_column; i < line.m_length - num; i++)
  501. line.characters[i] = line.characters[i + num];
  502. // Fill remainder of line with blanks
  503. for (int i = line.m_length - num; i < line.m_length; i++)
  504. line.characters[i] = ' ';
  505. line.dirty = true;
  506. }
  507. void Terminal::execute_xterm_command()
  508. {
  509. m_final = '@';
  510. bool ok;
  511. unsigned value = String::copy(m_xterm_param1).to_uint(ok);
  512. if (ok) {
  513. switch (value) {
  514. case 0:
  515. case 1:
  516. case 2:
  517. set_window_title(String::copy(m_xterm_param2));
  518. break;
  519. default:
  520. unimplemented_xterm_escape();
  521. break;
  522. }
  523. }
  524. m_xterm_param1.clear_with_capacity();
  525. m_xterm_param2.clear_with_capacity();
  526. }
  527. void Terminal::execute_escape_sequence(byte final)
  528. {
  529. bool question_param = false;
  530. m_final = final;
  531. ParamVector params;
  532. if (m_parameters.size() > 0 && m_parameters[0] == '?') {
  533. question_param = true;
  534. m_parameters.remove(0);
  535. }
  536. auto paramparts = String::copy(m_parameters).split(';');
  537. for (auto& parampart : paramparts) {
  538. bool ok;
  539. unsigned value = parampart.to_uint(ok);
  540. if (!ok) {
  541. // FIXME: Should we do something else?
  542. m_parameters.clear_with_capacity();
  543. m_intermediates.clear_with_capacity();
  544. return;
  545. }
  546. params.append(value);
  547. }
  548. #if defined(TERMINAL_DEBUG)
  549. dbgprintf("Terminal::execute_escape_sequence: Handled final '%c'\n", final);
  550. dbgprintf("Params: ");
  551. for (auto& p : params) {
  552. dbgprintf("%d ", p);
  553. }
  554. dbgprintf("\b\n");
  555. #endif
  556. switch (final) {
  557. case 'A':
  558. escape$A(params);
  559. break;
  560. case 'B':
  561. escape$B(params);
  562. break;
  563. case 'C':
  564. escape$C(params);
  565. break;
  566. case 'D':
  567. escape$D(params);
  568. break;
  569. case 'H':
  570. escape$H(params);
  571. break;
  572. case 'J':
  573. escape$J(params);
  574. break;
  575. case 'K':
  576. escape$K(params);
  577. break;
  578. case 'M':
  579. escape$M(params);
  580. break;
  581. case 'P':
  582. escape$P(params);
  583. break;
  584. case 'S':
  585. escape$S(params);
  586. break;
  587. case 'T':
  588. escape$T(params);
  589. break;
  590. case 'L':
  591. escape$L(params);
  592. break;
  593. case 'G':
  594. escape$G(params);
  595. break;
  596. case 'X':
  597. escape$X(params);
  598. break;
  599. case 'b':
  600. escape$b(params);
  601. break;
  602. case 'd':
  603. escape$d(params);
  604. break;
  605. case 'm':
  606. escape$m(params);
  607. break;
  608. case 's':
  609. escape$s(params);
  610. break;
  611. case 'u':
  612. escape$u(params);
  613. break;
  614. case 't':
  615. escape$t(params);
  616. break;
  617. case 'r':
  618. escape$r(params);
  619. break;
  620. case 'l':
  621. escape$h_l(true, question_param, params);
  622. break;
  623. case 'h':
  624. escape$h_l(false, question_param, params);
  625. break;
  626. default:
  627. dbgprintf("Terminal::execute_escape_sequence: Unhandled final '%c'\n", final);
  628. break;
  629. }
  630. #if defined(TERMINAL_DEBUG)
  631. dbgprintf("\n");
  632. for (auto& line : m_lines) {
  633. dbgprintf("Terminal: Line: ");
  634. for (int i = 0; i < line->length; i++) {
  635. dbgprintf("%c", line->characters[i]);
  636. }
  637. dbgprintf("\n");
  638. }
  639. #endif
  640. m_parameters.clear_with_capacity();
  641. m_intermediates.clear_with_capacity();
  642. }
  643. void Terminal::newline()
  644. {
  645. word new_row = m_cursor_row;
  646. if (m_cursor_row == m_scroll_region_bottom) {
  647. scroll_up();
  648. } else {
  649. ++new_row;
  650. }
  651. set_cursor(new_row, 0);
  652. }
  653. void Terminal::scroll_up()
  654. {
  655. // NOTE: We have to invalidate the cursor first.
  656. invalidate_cursor();
  657. m_lines.remove(m_scroll_region_top);
  658. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  659. m_need_full_flush = true;
  660. }
  661. void Terminal::scroll_down()
  662. {
  663. // NOTE: We have to invalidate the cursor first.
  664. invalidate_cursor();
  665. m_lines.remove(m_scroll_region_bottom);
  666. m_lines.insert(m_scroll_region_top, make<Line>(m_columns));
  667. m_need_full_flush = true;
  668. }
  669. void Terminal::set_cursor(unsigned a_row, unsigned a_column)
  670. {
  671. unsigned row = min(a_row, m_rows - 1u);
  672. unsigned column = min(a_column, m_columns - 1u);
  673. if (row == m_cursor_row && column == m_cursor_column)
  674. return;
  675. ASSERT(row < rows());
  676. ASSERT(column < columns());
  677. invalidate_cursor();
  678. m_cursor_row = row;
  679. m_cursor_column = column;
  680. if (column != columns() - 1u)
  681. m_stomp = false;
  682. invalidate_cursor();
  683. }
  684. void Terminal::put_character_at(unsigned row, unsigned column, byte ch)
  685. {
  686. ASSERT(row < rows());
  687. ASSERT(column < columns());
  688. auto& line = this->line(row);
  689. line.characters[column] = ch;
  690. line.attributes[column] = m_current_attribute;
  691. line.dirty = true;
  692. m_last_char = ch;
  693. }
  694. void Terminal::on_char(byte ch)
  695. {
  696. #ifdef TERMINAL_DEBUG
  697. dbgprintf("Terminal::on_char: %b (%c), fg=%u, bg=%u\n", ch, ch, m_current_attribute.foreground_color, m_current_attribute.background_color);
  698. #endif
  699. switch (m_escape_state) {
  700. case ExpectBracket:
  701. if (ch == '[')
  702. m_escape_state = ExpectParameter;
  703. else if (ch == '(') {
  704. m_swallow_current = true;
  705. m_escape_state = ExpectParameter;
  706. } else if (ch == ']')
  707. m_escape_state = ExpectXtermParameter1;
  708. else
  709. m_escape_state = Normal;
  710. return;
  711. case ExpectXtermParameter1:
  712. if (ch != ';') {
  713. m_xterm_param1.append(ch);
  714. return;
  715. }
  716. m_escape_state = ExpectXtermParameter2;
  717. return;
  718. case ExpectXtermParameter2:
  719. if (ch != '\007') {
  720. m_xterm_param2.append(ch);
  721. return;
  722. }
  723. m_escape_state = ExpectXtermFinal;
  724. [[fallthrough]];
  725. case ExpectXtermFinal:
  726. m_escape_state = Normal;
  727. if (ch == '\007')
  728. execute_xterm_command();
  729. return;
  730. case ExpectParameter:
  731. if (is_valid_parameter_character(ch)) {
  732. m_parameters.append(ch);
  733. return;
  734. }
  735. m_escape_state = ExpectIntermediate;
  736. [[fallthrough]];
  737. case ExpectIntermediate:
  738. if (is_valid_intermediate_character(ch)) {
  739. m_intermediates.append(ch);
  740. return;
  741. }
  742. m_escape_state = ExpectFinal;
  743. [[fallthrough]];
  744. case ExpectFinal:
  745. if (is_valid_final_character(ch)) {
  746. m_escape_state = Normal;
  747. if (!m_swallow_current)
  748. execute_escape_sequence(ch);
  749. m_swallow_current = false;
  750. return;
  751. }
  752. m_escape_state = Normal;
  753. m_swallow_current = false;
  754. return;
  755. case Normal:
  756. break;
  757. }
  758. switch (ch) {
  759. case '\0':
  760. return;
  761. case '\033':
  762. m_escape_state = ExpectBracket;
  763. m_swallow_current = false;
  764. return;
  765. case 8: // Backspace
  766. if (m_cursor_column) {
  767. set_cursor(m_cursor_row, m_cursor_column - 1);
  768. put_character_at(m_cursor_row, m_cursor_column, ' ');
  769. return;
  770. }
  771. return;
  772. case '\a':
  773. if (m_should_beep)
  774. sysbeep();
  775. else {
  776. m_visual_beep_timer.restart(200);
  777. m_visual_beep_timer.set_single_shot(true);
  778. m_visual_beep_timer.on_timeout = [this] {
  779. force_repaint();
  780. };
  781. force_repaint();
  782. }
  783. return;
  784. case '\t': {
  785. for (unsigned i = m_cursor_column; i < columns(); ++i) {
  786. if (m_horizontal_tabs[i]) {
  787. set_cursor(m_cursor_row, i);
  788. return;
  789. }
  790. }
  791. return;
  792. }
  793. case '\r':
  794. set_cursor(m_cursor_row, 0);
  795. return;
  796. case '\n':
  797. newline();
  798. return;
  799. }
  800. auto new_column = m_cursor_column + 1;
  801. if (new_column < columns()) {
  802. put_character_at(m_cursor_row, m_cursor_column, ch);
  803. set_cursor(m_cursor_row, new_column);
  804. } else {
  805. if (m_stomp) {
  806. m_stomp = false;
  807. newline();
  808. put_character_at(m_cursor_row, m_cursor_column, ch);
  809. set_cursor(m_cursor_row, 1);
  810. } else {
  811. // Curious: We wait once on the right-hand side
  812. m_stomp = true;
  813. put_character_at(m_cursor_row, m_cursor_column, ch);
  814. }
  815. }
  816. }
  817. void Terminal::inject_string(const String& str)
  818. {
  819. for (int i = 0; i < str.length(); ++i)
  820. on_char(str[i]);
  821. }
  822. void Terminal::unimplemented_escape()
  823. {
  824. StringBuilder builder;
  825. builder.appendf("((Unimplemented escape: %c", m_final);
  826. if (!m_parameters.is_empty()) {
  827. builder.append(" parameters:");
  828. for (int i = 0; i < m_parameters.size(); ++i)
  829. builder.append((char)m_parameters[i]);
  830. }
  831. if (!m_intermediates.is_empty()) {
  832. builder.append(" intermediates:");
  833. for (int i = 0; i < m_intermediates.size(); ++i)
  834. builder.append((char)m_intermediates[i]);
  835. }
  836. builder.append("))");
  837. inject_string(builder.to_string());
  838. }
  839. void Terminal::unimplemented_xterm_escape()
  840. {
  841. auto message = String::format("((Unimplemented xterm escape: %c))\n", m_final);
  842. inject_string(message);
  843. }
  844. void Terminal::set_size(word columns, word rows)
  845. {
  846. if (columns == m_columns && rows == m_rows)
  847. return;
  848. #if defined(TERMINAL_DEBUG)
  849. dbgprintf("Terminal: RESIZE to: %d rows\n", rows);
  850. #endif
  851. if (rows > m_rows) {
  852. while (m_lines.size() < rows)
  853. m_lines.append(make<Line>(columns));
  854. } else {
  855. m_lines.resize(rows);
  856. }
  857. for (int i = 0; i < rows; ++i)
  858. m_lines[i]->set_length(columns);
  859. m_columns = columns;
  860. m_rows = rows;
  861. m_scroll_region_top = 0;
  862. m_scroll_region_bottom = rows - 1;
  863. m_cursor_row = 0;
  864. m_cursor_column = 0;
  865. m_saved_cursor_row = 0;
  866. m_saved_cursor_column = 0;
  867. m_horizontal_tabs.resize(columns);
  868. for (unsigned i = 0; i < columns; ++i)
  869. m_horizontal_tabs[i] = (i % 8) == 0;
  870. // Rightmost column is always last tab on line.
  871. m_horizontal_tabs[columns - 1] = 1;
  872. m_pixel_width = (frame_thickness() * 2) + (m_inset * 2) + (m_columns * font().glyph_width('x'));
  873. m_pixel_height = (frame_thickness() * 2) + (m_inset * 2) + (m_rows * (font().glyph_height() + m_line_spacing)) - m_line_spacing;
  874. set_size_policy(SizePolicy::Fixed, SizePolicy::Fixed);
  875. set_preferred_size({ m_pixel_width, m_pixel_height });
  876. m_needs_background_fill = true;
  877. force_repaint();
  878. winsize ws;
  879. ws.ws_row = rows;
  880. ws.ws_col = columns;
  881. int rc = ioctl(m_ptm_fd, TIOCSWINSZ, &ws);
  882. ASSERT(rc == 0);
  883. }
  884. Rect Terminal::glyph_rect(word row, word column)
  885. {
  886. int y = row * m_line_height;
  887. int x = column * font().glyph_width('x');
  888. return { x + frame_thickness() + m_inset, y + frame_thickness() + m_inset, font().glyph_width('x'), font().glyph_height() };
  889. }
  890. Rect Terminal::row_rect(word row)
  891. {
  892. int y = row * m_line_height;
  893. Rect rect = { frame_thickness() + m_inset, y + frame_thickness() + m_inset, font().glyph_width('x') * m_columns, font().glyph_height() };
  894. rect.inflate(0, m_line_spacing);
  895. return rect;
  896. }
  897. bool Terminal::Line::has_only_one_background_color() const
  898. {
  899. if (!m_length)
  900. return true;
  901. // FIXME: Cache this result?
  902. auto color = attributes[0].background_color;
  903. for (size_t i = 1; i < m_length; ++i) {
  904. if (attributes[i].background_color != color)
  905. return false;
  906. }
  907. return true;
  908. }
  909. void Terminal::event(CEvent& event)
  910. {
  911. if (event.type() == GEvent::WindowBecameActive || event.type() == GEvent::WindowBecameInactive) {
  912. m_in_active_window = event.type() == GEvent::WindowBecameActive;
  913. if (!m_in_active_window) {
  914. m_cursor_blink_timer.stop();
  915. } else {
  916. m_cursor_blink_state = true;
  917. m_cursor_blink_timer.start();
  918. }
  919. invalidate_cursor();
  920. update();
  921. }
  922. return GWidget::event(event);
  923. }
  924. void Terminal::keydown_event(GKeyEvent& event)
  925. {
  926. char ch = !event.text().is_empty() ? event.text()[0] : 0;
  927. if (event.ctrl()) {
  928. if (ch >= 'a' && ch <= 'z') {
  929. ch = ch - 'a' + 1;
  930. } else if (ch == '\\') {
  931. ch = 0x1c;
  932. }
  933. }
  934. switch (event.key()) {
  935. case KeyCode::Key_Up:
  936. write(m_ptm_fd, "\033[A", 3);
  937. break;
  938. case KeyCode::Key_Down:
  939. write(m_ptm_fd, "\033[B", 3);
  940. break;
  941. case KeyCode::Key_Right:
  942. write(m_ptm_fd, "\033[C", 3);
  943. break;
  944. case KeyCode::Key_Left:
  945. write(m_ptm_fd, "\033[D", 3);
  946. break;
  947. case KeyCode::Key_Home:
  948. write(m_ptm_fd, "\033[H", 3);
  949. break;
  950. case KeyCode::Key_End:
  951. write(m_ptm_fd, "\033[F", 3);
  952. break;
  953. case KeyCode::Key_RightShift:
  954. // Prevent RightShift from being sent to whatever's running in the
  955. // terminal. Prevents `~@` (null) character from being sent after every
  956. // character entered with right shift.
  957. break;
  958. default:
  959. write(m_ptm_fd, &ch, 1);
  960. break;
  961. }
  962. }
  963. void Terminal::paint_event(GPaintEvent& event)
  964. {
  965. GFrame::paint_event(event);
  966. GPainter painter(*this);
  967. if (m_visual_beep_timer.is_active())
  968. painter.fill_rect(frame_inner_rect(), Color::Red);
  969. else
  970. painter.fill_rect(frame_inner_rect(), Color(Color::Black).with_alpha(255 * m_opacity));
  971. invalidate_cursor();
  972. for (word row = 0; row < m_rows; ++row) {
  973. auto& line = this->line(row);
  974. bool has_only_one_background_color = line.has_only_one_background_color();
  975. if (m_visual_beep_timer.is_active())
  976. painter.fill_rect(row_rect(row), Color::Red);
  977. else if (has_only_one_background_color)
  978. painter.fill_rect(row_rect(row), lookup_color(line.attributes[0].background_color).with_alpha(255 * m_opacity));
  979. for (word column = 0; column < m_columns; ++column) {
  980. char ch = line.characters[column];
  981. bool should_reverse_fill_for_cursor = m_cursor_blink_state && m_in_active_window && row == m_cursor_row && column == m_cursor_column;
  982. auto& attribute = line.attributes[column];
  983. auto character_rect = glyph_rect(row, column);
  984. if (!has_only_one_background_color || should_reverse_fill_for_cursor) {
  985. auto cell_rect = character_rect.inflated(0, m_line_spacing);
  986. painter.fill_rect(cell_rect, lookup_color(should_reverse_fill_for_cursor ? attribute.foreground_color : attribute.background_color).with_alpha(255 * m_opacity));
  987. }
  988. if (ch == ' ')
  989. continue;
  990. painter.draw_glyph(character_rect.location(), ch, lookup_color(should_reverse_fill_for_cursor ? attribute.background_color : attribute.foreground_color));
  991. }
  992. }
  993. if (!m_in_active_window) {
  994. auto cell_rect = glyph_rect(m_cursor_row, m_cursor_column).inflated(0, m_line_spacing);
  995. painter.draw_rect(cell_rect, lookup_color(line(m_cursor_row).attributes[m_cursor_column].foreground_color));
  996. }
  997. }
  998. void Terminal::set_window_title(const String& title)
  999. {
  1000. auto* w = window();
  1001. if (!w)
  1002. return;
  1003. w->set_title(title);
  1004. }
  1005. void Terminal::invalidate_cursor()
  1006. {
  1007. line(m_cursor_row).dirty = true;
  1008. }
  1009. void Terminal::flush_dirty_lines()
  1010. {
  1011. if (m_need_full_flush) {
  1012. update();
  1013. m_need_full_flush = false;
  1014. return;
  1015. }
  1016. Rect rect;
  1017. for (int i = 0; i < m_rows; ++i) {
  1018. if (line(i).dirty)
  1019. rect = rect.united(row_rect(i));
  1020. }
  1021. update(rect);
  1022. }
  1023. void Terminal::force_repaint()
  1024. {
  1025. m_needs_background_fill = true;
  1026. for (int i = 0; i < m_rows; ++i)
  1027. line(i).dirty = true;
  1028. update();
  1029. }
  1030. void Terminal::resize_event(GResizeEvent& event)
  1031. {
  1032. int new_columns = (event.size().width() - frame_thickness() * 2 - m_inset * 2) / font().glyph_width('x');
  1033. int new_rows = (event.size().height() - frame_thickness() * 2 - m_inset * 2) / m_line_height;
  1034. set_size(new_columns, new_rows);
  1035. }
  1036. void Terminal::apply_size_increments_to_window(GWindow& window)
  1037. {
  1038. window.set_size_increment({ font().glyph_width('x'), m_line_height });
  1039. window.set_base_size({ frame_thickness() * 2 + m_inset * 2, frame_thickness() * 2 + m_inset * 2 });
  1040. }
  1041. void Terminal::update_cursor()
  1042. {
  1043. invalidate_cursor();
  1044. flush_dirty_lines();
  1045. }
  1046. void Terminal::set_opacity(float opacity)
  1047. {
  1048. if (m_opacity == opacity)
  1049. return;
  1050. window()->set_has_alpha_channel(opacity < 1);
  1051. m_opacity = opacity;
  1052. force_repaint();
  1053. }