Terminal.cpp 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810
  1. #include "Terminal.h"
  2. #include "XtermColors.h"
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <stdio.h>
  8. #include <AK/AKString.h>
  9. #include <AK/StringBuilder.h>
  10. #include <SharedGraphics/Font.h>
  11. #include <SharedGraphics/Painter.h>
  12. #include <AK/StdLibExtras.h>
  13. #include <LibGUI/GApplication.h>
  14. #include <LibGUI/GWindow.h>
  15. #include <Kernel/KeyCode.h>
  16. #include <sys/ioctl.h>
  17. //#define TERMINAL_DEBUG
  18. Terminal::Terminal(int ptm_fd)
  19. : m_ptm_fd(ptm_fd)
  20. , m_notifier(ptm_fd, GNotifier::Read)
  21. {
  22. set_font(Font::default_fixed_width_font());
  23. m_notifier.on_ready_to_read = [this] (GNotifier& notifier) {
  24. byte buffer[BUFSIZ];
  25. ssize_t nread = read(notifier.fd(), buffer, sizeof(buffer));
  26. if (nread < 0) {
  27. dbgprintf("Terminal read error: %s\n", strerror(errno));
  28. perror("read(ptm)");
  29. GApplication::the().quit(1);
  30. return;
  31. }
  32. if (nread == 0) {
  33. dbgprintf("Terminal: EOF on master pty, closing.\n");
  34. GApplication::the().quit(0);
  35. return;
  36. }
  37. for (ssize_t i = 0; i < nread; ++i)
  38. on_char(buffer[i]);
  39. flush_dirty_lines();
  40. };
  41. set_fill_with_background_color(false);
  42. m_line_height = font().glyph_height() + m_line_spacing;
  43. set_size(80, 25);
  44. }
  45. Terminal::Line::Line(word columns)
  46. : length(columns)
  47. {
  48. characters = new byte[length];
  49. attributes = new Attribute[length];
  50. memset(characters, ' ', length);
  51. }
  52. Terminal::Line::~Line()
  53. {
  54. delete [] characters;
  55. delete [] attributes;
  56. }
  57. void Terminal::Line::clear(Attribute attribute)
  58. {
  59. if (dirty) {
  60. memset(characters, ' ', length);
  61. for (word i = 0 ; i < length; ++i)
  62. attributes[i] = attribute;
  63. return;
  64. }
  65. for (unsigned i = 0 ; i < length; ++i) {
  66. if (characters[i] != ' ')
  67. dirty = true;
  68. characters[i] = ' ';
  69. }
  70. for (unsigned i = 0 ; i < length; ++i) {
  71. if (attributes[i] != attribute)
  72. dirty = true;
  73. attributes[i] = attribute;
  74. }
  75. }
  76. Terminal::~Terminal()
  77. {
  78. for (int i = 0; i < m_rows; ++i)
  79. delete m_lines[i];
  80. delete [] m_lines;
  81. free(m_horizontal_tabs);
  82. }
  83. void Terminal::clear()
  84. {
  85. for (size_t i = 0; i < rows(); ++i)
  86. line(i).clear(m_current_attribute);
  87. set_cursor(0, 0);
  88. }
  89. inline bool is_valid_parameter_character(byte ch)
  90. {
  91. return ch >= 0x30 && ch <= 0x3f;
  92. }
  93. inline bool is_valid_intermediate_character(byte ch)
  94. {
  95. return ch >= 0x20 && ch <= 0x2f;
  96. }
  97. inline bool is_valid_final_character(byte ch)
  98. {
  99. return ch >= 0x40 && ch <= 0x7e;
  100. }
  101. unsigned parse_uint(const String& str, bool& ok)
  102. {
  103. unsigned value = 0;
  104. for (int i = 0; i < str.length(); ++i) {
  105. if (str[i] < '0' || str[i] > '9') {
  106. ok = false;
  107. return 0;
  108. }
  109. value = value * 10;
  110. value += str[i] - '0';
  111. }
  112. ok = true;
  113. return value;
  114. }
  115. static inline Color lookup_color(unsigned color)
  116. {
  117. return Color::from_rgb(xterm_colors[color]);
  118. }
  119. void Terminal::escape$m(const Vector<unsigned>& params)
  120. {
  121. if (params.size() == 3 && params[1] == 5) {
  122. if (params[0] == 38) {
  123. m_current_attribute.foreground_color = params[2];
  124. return;
  125. } else if (params[0] == 48) {
  126. m_current_attribute.background_color = params[2];
  127. return;
  128. }
  129. }
  130. for (auto param : params) {
  131. switch (param) {
  132. case 0:
  133. // Reset
  134. m_current_attribute.reset();
  135. break;
  136. case 1:
  137. // Bold
  138. //m_current_attribute.bold = true;
  139. break;
  140. case 30:
  141. case 31:
  142. case 32:
  143. case 33:
  144. case 34:
  145. case 35:
  146. case 36:
  147. case 37:
  148. // Foreground color
  149. m_current_attribute.foreground_color = param - 30;
  150. break;
  151. case 40:
  152. case 41:
  153. case 42:
  154. case 43:
  155. case 44:
  156. case 45:
  157. case 46:
  158. case 47:
  159. // Background color
  160. m_current_attribute.background_color = param - 40;
  161. break;
  162. }
  163. }
  164. }
  165. void Terminal::escape$s(const Vector<unsigned>&)
  166. {
  167. m_saved_cursor_row = m_cursor_row;
  168. m_saved_cursor_column = m_cursor_column;
  169. }
  170. void Terminal::escape$u(const Vector<unsigned>&)
  171. {
  172. set_cursor(m_saved_cursor_row, m_saved_cursor_column);
  173. }
  174. void Terminal::escape$t(const Vector<unsigned>& params)
  175. {
  176. if (params.size() < 1)
  177. return;
  178. dbgprintf("escape$t: Ps: %u\n", params[0]);
  179. }
  180. void Terminal::escape$H(const Vector<unsigned>& params)
  181. {
  182. unsigned row = 1;
  183. unsigned col = 1;
  184. if (params.size() >= 1)
  185. row = params[0];
  186. if (params.size() >= 2)
  187. col = params[1];
  188. set_cursor(row - 1, col - 1);
  189. }
  190. void Terminal::escape$A(const Vector<unsigned>& params)
  191. {
  192. int num = 1;
  193. if (params.size() >= 1)
  194. num = params[0];
  195. if (num == 0)
  196. num = 1;
  197. int new_row = (int)m_cursor_row - num;
  198. if (new_row < 0)
  199. new_row = 0;
  200. set_cursor(new_row, m_cursor_column);
  201. }
  202. void Terminal::escape$B(const Vector<unsigned>& params)
  203. {
  204. int num = 1;
  205. if (params.size() >= 1)
  206. num = params[0];
  207. if (num == 0)
  208. num = 1;
  209. int new_row = (int)m_cursor_row + num;
  210. if (new_row >= m_rows)
  211. new_row = m_rows - 1;
  212. set_cursor(new_row, m_cursor_column);
  213. }
  214. void Terminal::escape$C(const Vector<unsigned>& params)
  215. {
  216. int num = 1;
  217. if (params.size() >= 1)
  218. num = params[0];
  219. if (num == 0)
  220. num = 1;
  221. int new_column = (int)m_cursor_column + num;
  222. if (new_column >= m_columns)
  223. new_column = m_columns - 1;
  224. set_cursor(m_cursor_row, new_column);
  225. }
  226. void Terminal::escape$D(const Vector<unsigned>& params)
  227. {
  228. int num = 1;
  229. if (params.size() >= 1)
  230. num = params[0];
  231. if (num == 0)
  232. num = 1;
  233. int new_column = (int)m_cursor_column - num;
  234. if (new_column < 0)
  235. new_column = 0;
  236. set_cursor(m_cursor_row, new_column);
  237. }
  238. void Terminal::escape$K(const Vector<unsigned>& params)
  239. {
  240. int mode = 0;
  241. if (params.size() >= 1)
  242. mode = params[0];
  243. switch (mode) {
  244. case 0:
  245. // Clear from cursor to end of line.
  246. for (int i = m_cursor_column; i < m_columns; ++i) {
  247. put_character_at(m_cursor_row, i, ' ');
  248. }
  249. break;
  250. case 1:
  251. // FIXME: Clear from cursor to beginning of screen.
  252. unimplemented_escape();
  253. break;
  254. case 2:
  255. unimplemented_escape();
  256. break;
  257. default:
  258. unimplemented_escape();
  259. break;
  260. }
  261. }
  262. void Terminal::escape$J(const Vector<unsigned>& params)
  263. {
  264. int mode = 0;
  265. if (params.size() >= 1)
  266. mode = params[0];
  267. switch (mode) {
  268. case 0:
  269. // Clear from cursor to end of screen.
  270. for (int i = m_cursor_column; i < m_columns; ++i) {
  271. put_character_at(m_cursor_row, i, ' ');
  272. }
  273. for (int row = m_cursor_row + 1; row < m_rows; ++row) {
  274. for (int column = 0; column < m_columns; ++column) {
  275. put_character_at(row, column, ' ');
  276. }
  277. }
  278. break;
  279. case 1:
  280. // FIXME: Clear from cursor to beginning of screen.
  281. unimplemented_escape();
  282. break;
  283. case 2:
  284. clear();
  285. break;
  286. case 3:
  287. // FIXME: <esc>[3J should also clear the scrollback buffer.
  288. clear();
  289. break;
  290. default:
  291. unimplemented_escape();
  292. break;
  293. }
  294. }
  295. void Terminal::escape$M(const Vector<unsigned>& params)
  296. {
  297. int count = 1;
  298. if (params.size() >= 1)
  299. count = params[0];
  300. if (count == 1 && m_cursor_row == 0) {
  301. scroll_up();
  302. return;
  303. }
  304. int max_count = m_rows - m_cursor_row;
  305. count = min(count, max_count);
  306. dbgprintf("Delete %d line(s) starting from %d\n", count, m_cursor_row);
  307. // FIXME: Implement.
  308. ASSERT_NOT_REACHED();
  309. }
  310. void Terminal::execute_xterm_command()
  311. {
  312. m_final = '@';
  313. bool ok;
  314. unsigned value = parse_uint(String((const char*)m_xterm_param1.data(), m_xterm_param1.size()), ok);
  315. if (ok) {
  316. switch (value) {
  317. case 0:
  318. case 1:
  319. case 2:
  320. set_window_title(String((const char*)m_xterm_param2.data(), m_xterm_param2.size()));
  321. break;
  322. default:
  323. unimplemented_xterm_escape();
  324. break;
  325. }
  326. }
  327. m_xterm_param1.clear_with_capacity();
  328. m_xterm_param2.clear_with_capacity();
  329. }
  330. void Terminal::execute_escape_sequence(byte final)
  331. {
  332. m_final = final;
  333. auto paramparts = String((const char*)m_parameters.data(), m_parameters.size()).split(';');
  334. Vector<unsigned> params;
  335. for (auto& parampart : paramparts) {
  336. bool ok;
  337. unsigned value = parse_uint(parampart, ok);
  338. if (!ok) {
  339. m_parameters.clear_with_capacity();
  340. m_intermediates.clear_with_capacity();
  341. // FIXME: Should we do something else?
  342. return;
  343. }
  344. params.append(value);
  345. }
  346. switch (final) {
  347. case 'A': escape$A(params); break;
  348. case 'B': escape$B(params); break;
  349. case 'C': escape$C(params); break;
  350. case 'D': escape$D(params); break;
  351. case 'H': escape$H(params); break;
  352. case 'J': escape$J(params); break;
  353. case 'K': escape$K(params); break;
  354. case 'M': escape$M(params); break;
  355. case 'm': escape$m(params); break;
  356. case 's': escape$s(params); break;
  357. case 'u': escape$u(params); break;
  358. case 't': escape$t(params); break;
  359. default:
  360. dbgprintf("Terminal::execute_escape_sequence: Unhandled final '%c'\n", final);
  361. break;
  362. }
  363. m_parameters.clear_with_capacity();
  364. m_intermediates.clear_with_capacity();
  365. }
  366. void Terminal::newline()
  367. {
  368. word new_row = m_cursor_row;
  369. if (m_cursor_row == (rows() - 1)) {
  370. scroll_up();
  371. } else {
  372. ++new_row;
  373. }
  374. set_cursor(new_row, 0);
  375. }
  376. void Terminal::scroll_up()
  377. {
  378. // NOTE: We have to invalidate the cursor first.
  379. invalidate_cursor();
  380. delete m_lines[0];
  381. for (word row = 1; row < rows(); ++row)
  382. m_lines[row - 1] = m_lines[row];
  383. m_lines[m_rows - 1] = new Line(m_columns);
  384. ++m_rows_to_scroll_backing_store;
  385. m_need_full_flush = true;
  386. }
  387. void Terminal::set_cursor(unsigned a_row, unsigned a_column)
  388. {
  389. unsigned row = min(a_row, m_rows - 1u);
  390. unsigned column = min(a_column, m_columns - 1u);
  391. if (row == m_cursor_row && column == m_cursor_column)
  392. return;
  393. ASSERT(row < rows());
  394. ASSERT(column < columns());
  395. invalidate_cursor();
  396. m_cursor_row = row;
  397. m_cursor_column = column;
  398. if (column != columns() - 1)
  399. m_stomp = false;
  400. invalidate_cursor();
  401. }
  402. void Terminal::put_character_at(unsigned row, unsigned column, byte ch)
  403. {
  404. ASSERT(row < rows());
  405. ASSERT(column < columns());
  406. auto& line = this->line(row);
  407. if ((line.characters[column] == ch) && (line.attributes[column] == m_current_attribute))
  408. return;
  409. line.characters[column] = ch;
  410. line.attributes[column] = m_current_attribute;
  411. line.dirty = true;
  412. }
  413. void Terminal::on_char(byte ch)
  414. {
  415. #ifdef TERMINAL_DEBUG
  416. dbgprintf("Terminal::on_char: %b (%c), fg=%u, bg=%u\n", ch, ch, m_current_attribute.foreground_color, m_current_attribute.background_color);
  417. #endif
  418. switch (m_escape_state) {
  419. case ExpectBracket:
  420. if (ch == '[')
  421. m_escape_state = ExpectParameter;
  422. else if (ch == ']')
  423. m_escape_state = ExpectXtermParameter1;
  424. else
  425. m_escape_state = Normal;
  426. return;
  427. case ExpectXtermParameter1:
  428. if (ch != ';') {
  429. m_xterm_param1.append(ch);
  430. return;
  431. }
  432. m_escape_state = ExpectXtermParameter2;
  433. return;
  434. case ExpectXtermParameter2:
  435. if (ch != '\007') {
  436. m_xterm_param2.append(ch);
  437. return;
  438. }
  439. m_escape_state = ExpectXtermFinal;
  440. [[fallthrough]];
  441. case ExpectXtermFinal:
  442. m_escape_state = Normal;
  443. if (ch == '\007')
  444. execute_xterm_command();
  445. return;
  446. case ExpectParameter:
  447. if (is_valid_parameter_character(ch)) {
  448. m_parameters.append(ch);
  449. return;
  450. }
  451. m_escape_state = ExpectIntermediate;
  452. [[fallthrough]];
  453. case ExpectIntermediate:
  454. if (is_valid_intermediate_character(ch)) {
  455. m_intermediates.append(ch);
  456. return;
  457. }
  458. m_escape_state = ExpectFinal;
  459. [[fallthrough]];
  460. case ExpectFinal:
  461. if (is_valid_final_character(ch)) {
  462. m_escape_state = Normal;
  463. execute_escape_sequence(ch);
  464. return;
  465. }
  466. m_escape_state = Normal;
  467. return;
  468. case Normal:
  469. break;
  470. }
  471. switch (ch) {
  472. case '\0':
  473. return;
  474. case '\033':
  475. m_escape_state = ExpectBracket;
  476. return;
  477. case 8: // Backspace
  478. if (m_cursor_column) {
  479. set_cursor(m_cursor_row, m_cursor_column - 1);
  480. put_character_at(m_cursor_row, m_cursor_column, ' ');
  481. return;
  482. }
  483. return;
  484. case '\a':
  485. // FIXME: Bell!
  486. return;
  487. case '\t': {
  488. for (unsigned i = m_cursor_column; i < columns(); ++i) {
  489. if (m_horizontal_tabs[i]) {
  490. set_cursor(m_cursor_row, i);
  491. return;
  492. }
  493. }
  494. return;
  495. }
  496. case '\r':
  497. set_cursor(m_cursor_row, 0);
  498. return;
  499. case '\n':
  500. newline();
  501. return;
  502. }
  503. auto new_column = m_cursor_column + 1;
  504. if (new_column < columns()) {
  505. put_character_at(m_cursor_row, m_cursor_column, ch);
  506. set_cursor(m_cursor_row, new_column);
  507. } else {
  508. if (m_stomp) {
  509. m_stomp = false;
  510. newline();
  511. put_character_at(m_cursor_row, m_cursor_column, ch);
  512. set_cursor(m_cursor_row, 1);
  513. } else {
  514. // Curious: We wait once on the right-hand side
  515. m_stomp = true;
  516. put_character_at(m_cursor_row, m_cursor_column, ch);
  517. }
  518. }
  519. }
  520. void Terminal::inject_string(const String& str)
  521. {
  522. for (int i = 0; i < str.length(); ++i)
  523. on_char(str[i]);
  524. }
  525. void Terminal::unimplemented_escape()
  526. {
  527. StringBuilder builder;
  528. builder.appendf("((Unimplemented escape: %c", m_final);
  529. if (!m_parameters.is_empty()) {
  530. builder.append(" parameters:");
  531. for (int i = 0; i < m_parameters.size(); ++i)
  532. builder.append((char)m_parameters[i]);
  533. }
  534. if (!m_intermediates.is_empty()) {
  535. builder.append(" intermediates:");
  536. for (int i = 0; i < m_intermediates.size(); ++i)
  537. builder.append((char)m_intermediates[i]);
  538. }
  539. builder.append("))");
  540. inject_string(builder.to_string());
  541. }
  542. void Terminal::unimplemented_xterm_escape()
  543. {
  544. auto message = String::format("((Unimplemented xterm escape: %c))\n", m_final);
  545. inject_string(message);
  546. }
  547. void Terminal::set_size(word columns, word rows)
  548. {
  549. if (columns == m_columns && rows == m_rows)
  550. return;
  551. if (m_lines) {
  552. for (size_t i = 0; i < m_rows; ++i)
  553. delete m_lines[i];
  554. delete m_lines;
  555. }
  556. m_columns = columns;
  557. m_rows = rows;
  558. m_cursor_row = 0;
  559. m_cursor_column = 0;
  560. m_saved_cursor_row = 0;
  561. m_saved_cursor_column = 0;
  562. if (m_horizontal_tabs)
  563. free(m_horizontal_tabs);
  564. m_horizontal_tabs = static_cast<byte*>(malloc(columns));
  565. for (unsigned i = 0; i < columns; ++i)
  566. m_horizontal_tabs[i] = (i % 8) == 0;
  567. // Rightmost column is always last tab on line.
  568. m_horizontal_tabs[columns - 1] = 1;
  569. m_lines = new Line*[rows];
  570. for (size_t i = 0; i < rows; ++i)
  571. m_lines[i] = new Line(columns);
  572. m_pixel_width = m_columns * font().glyph_width('x') + m_inset * 2;
  573. m_pixel_height = (m_rows * (font().glyph_height() + m_line_spacing)) + (m_inset * 2) - m_line_spacing;
  574. set_size_policy(SizePolicy::Fixed, SizePolicy::Fixed);
  575. set_preferred_size({ m_pixel_width, m_pixel_height });
  576. m_rows_to_scroll_backing_store = 0;
  577. m_needs_background_fill = true;
  578. force_repaint();
  579. winsize ws;
  580. ws.ws_row = rows;
  581. ws.ws_col = columns;
  582. int rc = ioctl(m_ptm_fd, TIOCSWINSZ, &ws);
  583. ASSERT(rc == 0);
  584. }
  585. Rect Terminal::glyph_rect(word row, word column)
  586. {
  587. int y = row * m_line_height;
  588. int x = column * font().glyph_width('x');
  589. return { x + m_inset, y + m_inset, font().glyph_width('x'), font().glyph_height() };
  590. }
  591. Rect Terminal::row_rect(word row)
  592. {
  593. int y = row * m_line_height;
  594. Rect rect = { m_inset, y + m_inset, font().glyph_width('x') * m_columns, font().glyph_height() };
  595. rect.inflate(0, m_line_spacing);
  596. return rect;
  597. }
  598. bool Terminal::Line::has_only_one_background_color() const
  599. {
  600. if (!length)
  601. return true;
  602. // FIXME: Cache this result?
  603. auto color = attributes[0].background_color;
  604. for (size_t i = 1; i < length; ++i) {
  605. if (attributes[i].background_color != color)
  606. return false;
  607. }
  608. return true;
  609. }
  610. void Terminal::event(GEvent& event)
  611. {
  612. if (event.type() == GEvent::WindowBecameActive || event.type() == GEvent::WindowBecameInactive) {
  613. m_in_active_window = event.type() == GEvent::WindowBecameActive;
  614. invalidate_cursor();
  615. update();
  616. }
  617. return GWidget::event(event);
  618. }
  619. void Terminal::keydown_event(GKeyEvent& event)
  620. {
  621. char ch = !event.text().is_empty() ? event.text()[0] : 0;
  622. if (event.ctrl()) {
  623. if (ch >= 'a' && ch <= 'z') {
  624. ch = ch - 'a' + 1;
  625. } else if (ch == '\\') {
  626. ch = 0x1c;
  627. }
  628. }
  629. switch (event.key()) {
  630. case KeyCode::Key_Up:
  631. write(m_ptm_fd, "\033[A", 3);
  632. break;
  633. case KeyCode::Key_Down:
  634. write(m_ptm_fd, "\033[B", 3);
  635. break;
  636. case KeyCode::Key_Right:
  637. write(m_ptm_fd, "\033[C", 3);
  638. break;
  639. case KeyCode::Key_Left:
  640. write(m_ptm_fd, "\033[D", 3);
  641. break;
  642. default:
  643. write(m_ptm_fd, &ch, 1);
  644. break;
  645. }
  646. }
  647. void Terminal::paint_event(GPaintEvent&)
  648. {
  649. Painter painter(*this);
  650. if (m_needs_background_fill) {
  651. m_needs_background_fill = false;
  652. painter.fill_rect(rect(), Color(Color::Black).with_alpha(255 * m_opacity));
  653. }
  654. if (m_rows_to_scroll_backing_store && m_rows_to_scroll_backing_store < m_rows) {
  655. int first_scanline = m_inset;
  656. int second_scanline = m_inset + (m_rows_to_scroll_backing_store * m_line_height);
  657. int num_rows_to_memcpy = m_rows - m_rows_to_scroll_backing_store;
  658. int scanlines_to_copy = (num_rows_to_memcpy * m_line_height) - m_line_spacing;
  659. fast_dword_copy(
  660. painter.target()->scanline(first_scanline),
  661. painter.target()->scanline(second_scanline),
  662. scanlines_to_copy * m_pixel_width
  663. );
  664. line(max(0, m_cursor_row - m_rows_to_scroll_backing_store)).dirty = true;
  665. }
  666. m_rows_to_scroll_backing_store = 0;
  667. invalidate_cursor();
  668. for (word row = 0; row < m_rows; ++row) {
  669. auto& line = this->line(row);
  670. if (!line.dirty)
  671. continue;
  672. line.dirty = false;
  673. bool has_only_one_background_color = line.has_only_one_background_color();
  674. if (has_only_one_background_color) {
  675. painter.fill_rect(row_rect(row), lookup_color(line.attributes[0].background_color).with_alpha(255 * m_opacity));
  676. }
  677. for (word column = 0; column < m_columns; ++column) {
  678. bool should_reverse_fill_for_cursor = m_in_active_window && row == m_cursor_row && column == m_cursor_column;
  679. auto& attribute = line.attributes[column];
  680. char ch = line.characters[column];
  681. auto character_rect = glyph_rect(row, column);
  682. if (!has_only_one_background_color || should_reverse_fill_for_cursor) {
  683. auto cell_rect = character_rect.inflated(0, m_line_spacing);
  684. painter.fill_rect(cell_rect, lookup_color(should_reverse_fill_for_cursor ? attribute.foreground_color : attribute.background_color).with_alpha(255 * m_opacity));
  685. }
  686. if (ch == ' ')
  687. continue;
  688. painter.draw_glyph(character_rect.location(), ch, lookup_color(should_reverse_fill_for_cursor ? attribute.background_color : attribute.foreground_color));
  689. }
  690. }
  691. if (!m_in_active_window) {
  692. auto cell_rect = glyph_rect(m_cursor_row, m_cursor_column).inflated(0, m_line_spacing);
  693. painter.draw_rect(cell_rect, lookup_color(line(m_cursor_row).attributes[m_cursor_column].foreground_color));
  694. }
  695. if (m_belling)
  696. painter.draw_rect(rect(), Color::Red);
  697. }
  698. void Terminal::set_window_title(String&& title)
  699. {
  700. auto* w = window();
  701. if (!w)
  702. return;
  703. w->set_title(move(title));
  704. }
  705. void Terminal::invalidate_cursor()
  706. {
  707. line(m_cursor_row).dirty = true;
  708. }
  709. void Terminal::flush_dirty_lines()
  710. {
  711. if (m_need_full_flush) {
  712. update();
  713. m_need_full_flush = false;
  714. return;
  715. }
  716. Rect rect;
  717. for (int i = 0; i < m_rows; ++i) {
  718. if (line(i).dirty)
  719. rect = rect.united(row_rect(i));
  720. }
  721. update(rect);
  722. }
  723. void Terminal::force_repaint()
  724. {
  725. for (int i = 0; i < m_rows; ++i)
  726. line(i).dirty = true;
  727. update();
  728. }
  729. void Terminal::resize_event(GResizeEvent& event)
  730. {
  731. int new_columns = event.size().width() / font().glyph_width('x');
  732. int new_rows = event.size().height() / m_line_height;
  733. set_size(new_columns, new_rows);
  734. }
  735. void Terminal::apply_size_increments_to_window(GWindow& window)
  736. {
  737. window.set_size_increment({ font().glyph_width('x'), m_line_height });
  738. window.set_base_size({ m_inset * 2, m_inset * 2});
  739. }