VimEditingEngine.cpp 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407
  1. /*
  2. * Copyright (c) 2020-2021, the SerenityOS developers.
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Assertions.h>
  7. #include <AK/String.h>
  8. #include <LibGUI/Event.h>
  9. #include <LibGUI/TextEditor.h>
  10. #include <LibGUI/VimEditingEngine.h>
  11. #include <string.h>
  12. namespace GUI {
  13. void VimCursor::move()
  14. {
  15. if (m_forwards)
  16. move_forwards();
  17. else
  18. move_backwards();
  19. }
  20. void VimCursor::move_reverse()
  21. {
  22. if (m_forwards)
  23. move_backwards();
  24. else
  25. move_forwards();
  26. }
  27. u32 VimCursor::peek()
  28. {
  29. TextPosition saved_position = m_position;
  30. move();
  31. u32 peeked = current_char();
  32. m_position = saved_position;
  33. return peeked;
  34. }
  35. u32 VimCursor::peek_reverse()
  36. {
  37. TextPosition saved_position = m_position;
  38. move_reverse();
  39. u32 peeked = current_char();
  40. m_position = saved_position;
  41. return peeked;
  42. }
  43. TextDocumentLine& VimCursor::current_line()
  44. {
  45. return m_editor.line(m_position.line());
  46. }
  47. u32 VimCursor::current_char()
  48. {
  49. if (on_empty_line()) {
  50. // Fails all of isspace, ispunct, isalnum so should be good.
  51. return 0;
  52. } else {
  53. return current_line().view().code_points()[m_position.column()];
  54. }
  55. }
  56. bool VimCursor::on_empty_line()
  57. {
  58. return current_line().length() == 0;
  59. }
  60. bool VimCursor::will_cross_line_boundary()
  61. {
  62. if (on_empty_line())
  63. return true;
  64. else if (m_forwards && m_position.column() == current_line().length() - 1)
  65. return true;
  66. else if (!m_forwards && m_position.column() == 0)
  67. return true;
  68. else
  69. return false;
  70. }
  71. void VimCursor::move_forwards()
  72. {
  73. if (on_empty_line() || m_position.column() == current_line().length() - 1) {
  74. if (m_position.line() == m_editor.line_count() - 1) {
  75. // We have reached the end of the document, so any other
  76. // forward movements are no-ops.
  77. m_hit_edge = true;
  78. } else {
  79. m_position.set_column(0);
  80. m_position.set_line(m_position.line() + 1);
  81. m_crossed_line_boundary = true;
  82. }
  83. } else {
  84. m_position.set_column(m_position.column() + 1);
  85. m_crossed_line_boundary = false;
  86. }
  87. }
  88. void VimCursor::move_backwards()
  89. {
  90. if (m_position.column() == 0) {
  91. if (m_position.line() == 0) {
  92. // We have reached the start of the document, so any other
  93. // backward movements are no-ops.
  94. m_hit_edge = true;
  95. } else {
  96. m_position.set_line(m_position.line() - 1);
  97. if (!on_empty_line())
  98. m_position.set_column(current_line().length() - 1);
  99. else
  100. m_position.set_column(0);
  101. m_crossed_line_boundary = true;
  102. }
  103. } else {
  104. m_position.set_column(m_position.column() - 1);
  105. m_crossed_line_boundary = false;
  106. }
  107. }
  108. void VimMotion::add_key_code(KeyCode key, [[maybe_unused]] bool ctrl, bool shift, [[maybe_unused]] bool alt)
  109. {
  110. if (is_complete())
  111. return;
  112. if (m_find_mode != FindMode::None) {
  113. // We need to consume the next character because we are going to find
  114. // until that character.
  115. // HACK: there is no good way to obtain whether a character is alphanumeric
  116. // from the keycode itself.
  117. char const* keycode_str = key_code_to_string(key);
  118. if (strlen(keycode_str) == 1 && (isalpha(keycode_str[0]) || isspace(keycode_str[0]))) {
  119. m_next_character = tolower(keycode_str[0]);
  120. m_unit = Unit::Find;
  121. } else {
  122. m_unit = Unit::Unknown;
  123. }
  124. m_is_complete = true;
  125. m_should_consume_next_character = false;
  126. return;
  127. }
  128. bool should_use_guirky = m_guirky_mode;
  129. switch (key) {
  130. #define DIGIT(n) \
  131. case KeyCode::Key_##n: \
  132. m_amount = (m_amount * 10) + n; \
  133. break
  134. // Digits add digits to the amount.
  135. DIGIT(1);
  136. DIGIT(2);
  137. DIGIT(3);
  138. DIGIT(4);
  139. DIGIT(5);
  140. DIGIT(6);
  141. DIGIT(7);
  142. DIGIT(8);
  143. DIGIT(9);
  144. #undef DIGIT
  145. // Home means to the beginning of the line.
  146. case KeyCode::Key_Home:
  147. m_unit = Unit::Character;
  148. m_amount = START_OF_LINE;
  149. m_is_complete = true;
  150. break;
  151. // If 0 appears while amount is 0, then it means beginning of line.
  152. // Otherwise, it adds 0 to the amount.
  153. case KeyCode::Key_0:
  154. if (m_amount == 0) {
  155. m_unit = Unit::Character;
  156. m_amount = START_OF_LINE;
  157. m_is_complete = true;
  158. } else {
  159. m_amount = m_amount * 10;
  160. }
  161. break;
  162. // End or $ means end of line.
  163. // TODO: d2$ in vim deletes to the end of the line and then the next line.
  164. case KeyCode::Key_End:
  165. case KeyCode::Key_Dollar:
  166. m_unit = Unit::Character;
  167. m_amount = END_OF_LINE;
  168. m_is_complete = true;
  169. break;
  170. // ^ means the first non-whitespace character for this line.
  171. // It deletes backwards if you're in front of it, and forwards if you're behind.
  172. case KeyCode::Key_Circumflex:
  173. m_unit = Unit::Character;
  174. m_amount = START_OF_NON_WHITESPACE;
  175. m_is_complete = true;
  176. break;
  177. // j, down or + operates on this line and amount line(s) after.
  178. case KeyCode::Key_J:
  179. case KeyCode::Key_Down:
  180. case KeyCode::Key_Plus:
  181. m_unit = Unit::Line;
  182. if (m_amount == 0)
  183. m_amount = 1;
  184. m_is_complete = true;
  185. break;
  186. // k, up or - operates on this line and amount line(s) before.
  187. case KeyCode::Key_K:
  188. case KeyCode::Key_Up:
  189. case KeyCode::Key_Minus:
  190. m_unit = Unit::Line;
  191. if (m_amount == 0)
  192. m_amount = -1;
  193. else
  194. m_amount = -m_amount;
  195. m_is_complete = true;
  196. break;
  197. // BS, h or left operates on this character and amount character(s) before.
  198. case KeyCode::Key_Backspace:
  199. case KeyCode::Key_H:
  200. case KeyCode::Key_Left:
  201. m_unit = Unit::Character;
  202. if (m_amount == 0)
  203. m_amount = -1;
  204. else
  205. m_amount = -m_amount;
  206. m_is_complete = true;
  207. break;
  208. // l or right operates on this character and amount character(s) after.
  209. case KeyCode::Key_L:
  210. case KeyCode::Key_Right:
  211. m_unit = Unit::Character;
  212. if (m_amount > 0)
  213. m_amount--;
  214. m_is_complete = true;
  215. break;
  216. // w operates on amount word(s) after.
  217. // W operates on amount WORD(s) after.
  218. case KeyCode::Key_W:
  219. if (shift)
  220. m_unit = Unit::WORD;
  221. else
  222. m_unit = Unit::Word;
  223. if (m_amount == 0)
  224. m_amount = 1;
  225. m_is_complete = true;
  226. break;
  227. // b operates on amount word(s) before.
  228. // B operates on amount WORD(s) before.
  229. case KeyCode::Key_B:
  230. if (shift)
  231. m_unit = Unit::WORD;
  232. else
  233. m_unit = Unit::Word;
  234. if (m_amount == 0)
  235. m_amount = -1;
  236. else
  237. m_amount = -m_amount;
  238. m_is_complete = true;
  239. break;
  240. // e operates on amount of word(s) after, till the end of the last word.
  241. // E operates on amount of WORD(s) after, till the end of the last WORD.
  242. // ge operates on amount of word(s) before, till the end of the last word.
  243. // gE operates on amount of WORD(s) before, till the end of the last WORD.
  244. case KeyCode::Key_E:
  245. if (shift)
  246. m_unit = Unit::EndOfWORD;
  247. else
  248. m_unit = Unit::EndOfWord;
  249. if (m_guirky_mode) {
  250. if (m_amount == 0)
  251. m_amount = -1;
  252. else
  253. m_amount = -m_amount;
  254. m_guirky_mode = false;
  255. } else {
  256. if (m_amount == 0)
  257. m_amount = 1;
  258. }
  259. m_is_complete = true;
  260. break;
  261. // g enables guirky (g-prefix commands) mode.
  262. // gg operates from the start of the document to the cursor.
  263. // G operates from the cursor to the end of the document.
  264. case KeyCode::Key_G:
  265. if (m_guirky_mode) {
  266. if (shift) {
  267. // gG is not a valid command in vim.
  268. m_guirky_mode = false;
  269. m_unit = Unit::Unknown;
  270. m_is_complete = true;
  271. } else {
  272. m_guirky_mode = false;
  273. m_unit = Unit::Document;
  274. m_amount = -1;
  275. m_is_complete = true;
  276. }
  277. } else {
  278. if (shift) {
  279. m_unit = Unit::Document;
  280. m_amount = 1;
  281. m_is_complete = true;
  282. } else {
  283. m_guirky_mode = true;
  284. }
  285. }
  286. break;
  287. // t operates until the given character.
  288. case KeyCode::Key_T:
  289. m_find_mode = FindMode::To;
  290. m_should_consume_next_character = true;
  291. if (m_amount == 0)
  292. m_amount = 1;
  293. break;
  294. // f operates through the given character.
  295. case KeyCode::Key_F:
  296. m_find_mode = FindMode::Find;
  297. m_should_consume_next_character = true;
  298. if (m_amount == 0)
  299. m_amount = 1;
  300. break;
  301. default:
  302. m_unit = Unit::Unknown;
  303. m_is_complete = true;
  304. break;
  305. }
  306. if (should_use_guirky && m_guirky_mode) {
  307. // If we didn't use the g then we cancel the motion.
  308. m_guirky_mode = false;
  309. m_unit = Unit::Unknown;
  310. m_is_complete = true;
  311. }
  312. }
  313. Optional<TextRange> VimMotion::get_range(VimEditingEngine& engine, bool normalize_for_position)
  314. {
  315. if (!is_complete() || is_cancelled())
  316. return {};
  317. TextEditor& editor = engine.editor();
  318. auto position = editor.cursor();
  319. int amount = abs(m_amount);
  320. bool forwards = m_amount >= 0;
  321. VimCursor cursor { editor, position, forwards };
  322. m_start_line = m_end_line = position.line();
  323. m_start_column = m_end_column = position.column();
  324. switch (m_unit) {
  325. case Unit::Unknown:
  326. VERIFY_NOT_REACHED();
  327. case Unit::Document: {
  328. calculate_document_range(editor);
  329. break;
  330. }
  331. case Unit::Line: {
  332. calculate_line_range(editor, normalize_for_position);
  333. break;
  334. }
  335. case Unit::EndOfWord:
  336. case Unit::Word:
  337. case Unit::EndOfWORD:
  338. case Unit::WORD: {
  339. calculate_word_range(cursor, amount, normalize_for_position);
  340. break;
  341. }
  342. case Unit::Character: {
  343. calculate_character_range(cursor, amount, normalize_for_position);
  344. break;
  345. }
  346. case Unit::Find: {
  347. calculate_find_range(cursor, amount);
  348. break;
  349. }
  350. }
  351. return { TextRange { { m_start_line, m_start_column }, { m_end_line, m_end_column } } };
  352. }
  353. Optional<TextRange> VimMotion::get_repeat_range(VimEditingEngine& engine, VimMotion::Unit unit, bool normalize_for_position)
  354. {
  355. TextEditor& editor = engine.editor();
  356. if (m_amount > 0) {
  357. m_amount--;
  358. } else if (m_amount < 0) {
  359. m_amount++;
  360. }
  361. auto position = editor.cursor();
  362. int amount = abs(m_amount);
  363. bool forwards = m_amount >= 0;
  364. VimCursor cursor { editor, position, forwards };
  365. m_start_line = m_end_line = position.line();
  366. m_start_column = m_end_column = position.column();
  367. switch (unit) {
  368. case Unit::Line: {
  369. calculate_line_range(editor, normalize_for_position);
  370. break;
  371. }
  372. case Unit::Character: {
  373. calculate_character_range(cursor, amount, normalize_for_position);
  374. break;
  375. }
  376. default:
  377. return {};
  378. }
  379. return { TextRange { { m_start_line, m_start_column }, { m_end_line, m_end_column } } };
  380. }
  381. void VimMotion::calculate_document_range(TextEditor& editor)
  382. {
  383. if (m_amount >= 0) {
  384. m_end_line = editor.line_count() - 1;
  385. auto& last_line = editor.line(m_end_line);
  386. m_end_column = last_line.length();
  387. } else {
  388. m_start_line = 0;
  389. m_start_column = 0;
  390. }
  391. }
  392. void VimMotion::calculate_line_range(TextEditor& editor, bool normalize_for_position)
  393. {
  394. // Use this line +/- m_amount lines.
  395. m_start_column = 0;
  396. m_end_column = 0;
  397. if (m_amount >= 0) {
  398. m_end_line = min(m_end_line + !normalize_for_position + m_amount, editor.line_count());
  399. // We can't delete to "last line + 1", so if we're on the last line,
  400. // delete until the end.
  401. if (m_end_line == editor.line_count()) {
  402. m_end_line--;
  403. m_end_column = editor.line(m_end_line).length();
  404. }
  405. } else {
  406. // Can't write it as max(start_line + m_amount, 0) because of unsigned
  407. // shenanigans.
  408. if (m_start_line <= (unsigned)-m_amount)
  409. m_start_line = 0;
  410. else
  411. m_start_line += m_amount;
  412. if (m_end_line == editor.line_count() - 1)
  413. m_end_column = editor.line(m_end_line).length();
  414. else
  415. m_end_line++;
  416. }
  417. }
  418. void VimMotion::calculate_word_range(VimCursor& cursor, int amount, bool normalize_for_position)
  419. {
  420. enum {
  421. Whitespace,
  422. Word,
  423. Punctuation,
  424. Unknown
  425. };
  426. // Word is defined as a-zA-Z0-9_.
  427. auto part_of_word = [](u32 ch) { return ch == '_' || isalnum(ch); };
  428. auto part_of_punctuation = [](u32 ch) { return ch != '_' && ispunct(ch); };
  429. auto classify = [&](u32 ch) {
  430. if (isspace(ch))
  431. return Whitespace;
  432. else if (part_of_word(ch))
  433. return Word;
  434. else if (part_of_punctuation(ch))
  435. return Punctuation;
  436. else
  437. return Unknown;
  438. };
  439. // A small explanation for the code below: Because the direction of the
  440. // movement for this motion determines what the "start" and "end" of a word
  441. // is, the code below treats the motions like so:
  442. // - Start of word: w/W/ge/gE
  443. // - End of word: e/E/b/B
  444. while (amount > 0) {
  445. if (cursor.hit_edge())
  446. break;
  447. if ((!cursor.forwards() && (m_unit == Unit::Word || m_unit == Unit::WORD))
  448. || (cursor.forwards() && (m_unit == Unit::EndOfWord || m_unit == Unit::EndOfWORD))) {
  449. // End-of-word motions peek at the "next" character and if its class
  450. // is not the same as ours, they move over one character (to end up
  451. // at the new character class). This is required because we don't
  452. // want to exit the word with end-of-word motions.
  453. if (m_unit == Unit::Word || m_unit == Unit::EndOfWord) {
  454. // Word-style peeking
  455. int current_class = classify(cursor.current_char());
  456. int peeked_class = classify(cursor.peek());
  457. if (current_class != peeked_class) {
  458. cursor.move();
  459. }
  460. } else {
  461. // WORD-style peeking, much simpler
  462. if (isspace(cursor.peek())) {
  463. cursor.move();
  464. }
  465. }
  466. } else {
  467. // Start-of-word motions want to exit the word no matter which part
  468. // of it we're in.
  469. if (m_unit == Unit::Word || m_unit == Unit::EndOfWord) {
  470. // Word-style consumption
  471. if (part_of_word(cursor.current_char())) {
  472. do {
  473. cursor.move();
  474. if (cursor.hit_edge() || cursor.crossed_line_boundary())
  475. break;
  476. } while (part_of_word(cursor.current_char()));
  477. } else if (part_of_punctuation(cursor.current_char())) {
  478. do {
  479. cursor.move();
  480. if (cursor.hit_edge() || cursor.crossed_line_boundary())
  481. break;
  482. } while (part_of_punctuation(cursor.current_char()));
  483. } else if (cursor.on_empty_line()) {
  484. cursor.move();
  485. }
  486. } else {
  487. // WORD-style consumption
  488. if (!isspace(cursor.current_char())) {
  489. do {
  490. cursor.move();
  491. if (cursor.hit_edge() || cursor.crossed_line_boundary())
  492. break;
  493. } while (!isspace(cursor.current_char()));
  494. } else if (cursor.on_empty_line()) {
  495. cursor.move();
  496. }
  497. }
  498. }
  499. // Now consume any space if it exists.
  500. if (isspace(cursor.current_char())) {
  501. do {
  502. cursor.move();
  503. if (cursor.hit_edge())
  504. break;
  505. } while (isspace(cursor.current_char()));
  506. }
  507. if ((!cursor.forwards() && (m_unit == Unit::Word || m_unit == Unit::WORD))
  508. || (cursor.forwards() && (m_unit == Unit::EndOfWord || m_unit == Unit::EndOfWORD))) {
  509. // End-of-word motions consume until the class doesn't match.
  510. if (m_unit == Unit::Word || m_unit == Unit::EndOfWord) {
  511. // Word-style consumption
  512. int current_class = classify(cursor.current_char());
  513. while (classify(cursor.current_char()) == current_class) {
  514. cursor.move();
  515. if (cursor.hit_edge() || cursor.crossed_line_boundary())
  516. break;
  517. }
  518. } else {
  519. // WORD-style consumption
  520. while (!isspace(cursor.current_char())) {
  521. cursor.move();
  522. if (cursor.hit_edge() || cursor.crossed_line_boundary())
  523. break;
  524. }
  525. }
  526. }
  527. amount--;
  528. }
  529. // If we need to normalize for position then we do a move_reverse for
  530. // end-of-word motions, because vim acts on end-of-word ranges through the
  531. // character your cursor is placed on but acts on start-of-words *until* the
  532. // character your cursor is placed on.
  533. if (normalize_for_position) {
  534. if ((!cursor.forwards() && (m_unit == Unit::Word || m_unit == Unit::WORD))
  535. || (cursor.forwards() && (m_unit == Unit::EndOfWord || m_unit == Unit::EndOfWORD))) {
  536. if (!cursor.hit_edge())
  537. cursor.move_reverse();
  538. }
  539. }
  540. if (cursor.forwards()) {
  541. m_end_line = cursor.current_position().line();
  542. m_end_column = cursor.current_position().column() + normalize_for_position;
  543. } else {
  544. m_start_line = cursor.current_position().line();
  545. m_start_column = cursor.current_position().column();
  546. }
  547. }
  548. void VimMotion::calculate_character_range(VimCursor& cursor, int amount, bool normalize_for_position)
  549. {
  550. if (m_amount == START_OF_LINE) {
  551. m_start_column = 0;
  552. } else if (m_amount == END_OF_LINE) {
  553. m_end_column = cursor.current_line().length();
  554. } else if (m_amount == START_OF_NON_WHITESPACE) {
  555. // Find the first non-whitespace character and set the range from current
  556. // position to it.
  557. TextPosition cursor_copy = cursor.current_position();
  558. cursor.current_position().set_column(0);
  559. while (isspace(cursor.current_char())) {
  560. if (cursor.will_cross_line_boundary())
  561. break;
  562. cursor.move_forwards();
  563. }
  564. if (cursor_copy < cursor.current_position())
  565. m_end_column = cursor.current_position().column() + 1;
  566. else
  567. m_start_column = cursor.current_position().column();
  568. } else {
  569. while (amount > 0) {
  570. if (cursor.hit_edge() || cursor.will_cross_line_boundary())
  571. break;
  572. cursor.move();
  573. amount--;
  574. }
  575. if (cursor.forwards()) {
  576. m_end_column = cursor.current_position().column() + 1 + normalize_for_position;
  577. } else {
  578. m_start_column = cursor.current_position().column();
  579. }
  580. }
  581. }
  582. void VimMotion::calculate_find_range(VimCursor& cursor, int amount)
  583. {
  584. // Find the searched character (case-insensitive).
  585. while (amount > 0) {
  586. cursor.move_forwards();
  587. while ((unsigned)tolower(cursor.current_char()) != m_next_character) {
  588. if (cursor.will_cross_line_boundary())
  589. break;
  590. cursor.move_forwards();
  591. }
  592. amount--;
  593. }
  594. // If we didn't find our character before reaching the end of the line, then
  595. // we want the range to be invalid so no operation is performed.
  596. if ((unsigned)tolower(cursor.current_char()) == m_next_character) {
  597. // We found our character.
  598. bool in_find_mode = m_find_mode == FindMode::Find;
  599. m_end_column = cursor.current_position().column() + in_find_mode;
  600. }
  601. m_find_mode = FindMode::None;
  602. }
  603. Optional<TextPosition> VimMotion::get_position(VimEditingEngine& engine, bool in_visual_mode)
  604. {
  605. auto range_optional = get_range(engine, true);
  606. if (!range_optional.has_value())
  607. return {};
  608. auto range = range_optional.value();
  609. if (!range.is_valid())
  610. return {};
  611. TextEditor& editor = engine.editor();
  612. auto cursor_position = editor.cursor();
  613. switch (m_unit) {
  614. case Unit::Document: {
  615. if (range.start().line() < cursor_position.line()) {
  616. cursor_position.set_line(range.start().line());
  617. } else {
  618. cursor_position.set_line(range.end().line());
  619. }
  620. cursor_position.set_column(0);
  621. return { cursor_position };
  622. }
  623. case Unit::Line: {
  624. size_t line_number;
  625. // Because we select lines from start to end, we can't use that
  626. // to get the new position, so we do some correction here.
  627. if (range.start().line() < cursor_position.line() || m_amount < 0) {
  628. line_number = range.start().line();
  629. } else {
  630. line_number = range.end().line();
  631. }
  632. auto& line = editor.line(line_number);
  633. cursor_position.set_line(line_number);
  634. if (line.length() <= cursor_position.column()) {
  635. cursor_position.set_column(line.length() - 1);
  636. }
  637. return { cursor_position };
  638. }
  639. default: {
  640. if (range.start() < cursor_position) {
  641. return { range.start() };
  642. } else {
  643. // Ranges are end-exclusive. The normalize_for_position argument we pass
  644. // above in get_range normalizes some values which shouldn't be
  645. // end-exclusive during normal operations.
  646. bool is_at_start = range.end().column() == 0;
  647. auto& line = editor.line(range.end().line());
  648. size_t column = is_at_start ? 0 : range.end().column() - 1;
  649. column = min(column, line.length() - (in_visual_mode ? 0 : 1));
  650. // Need to not go beyond the last character, as standard in vim.
  651. return { TextPosition { range.end().line(), column } };
  652. }
  653. }
  654. }
  655. }
  656. void VimMotion::reset()
  657. {
  658. m_unit = Unit::Unknown;
  659. m_amount = 0;
  660. m_is_complete = false;
  661. }
  662. CursorWidth VimEditingEngine::cursor_width() const
  663. {
  664. return m_vim_mode == VimMode::Insert ? CursorWidth::NARROW : CursorWidth::WIDE;
  665. }
  666. bool VimEditingEngine::on_key(const KeyEvent& event)
  667. {
  668. switch (m_vim_mode) {
  669. case (VimMode::Insert):
  670. return on_key_in_insert_mode(event);
  671. case (VimMode::Visual):
  672. return on_key_in_visual_mode(event);
  673. case (VimMode::Normal):
  674. return on_key_in_normal_mode(event);
  675. default:
  676. VERIFY_NOT_REACHED();
  677. }
  678. return false;
  679. }
  680. bool VimEditingEngine::on_key_in_insert_mode(const KeyEvent& event)
  681. {
  682. if (EditingEngine::on_key(event))
  683. return true;
  684. if (event.ctrl()) {
  685. switch (event.key()) {
  686. case KeyCode::Key_W:
  687. m_editor->delete_previous_word();
  688. return true;
  689. case KeyCode::Key_H:
  690. m_editor->delete_previous_char();
  691. return true;
  692. case KeyCode::Key_U:
  693. m_editor->delete_from_line_start_to_cursor();
  694. return true;
  695. default:
  696. break;
  697. }
  698. }
  699. if (event.key() == KeyCode::Key_Escape || (event.ctrl() && event.key() == KeyCode::Key_LeftBracket) || (event.ctrl() && event.key() == KeyCode::Key_C)) {
  700. if (m_editor->cursor().column() > 0)
  701. move_one_left();
  702. switch_to_normal_mode();
  703. return true;
  704. }
  705. return false;
  706. }
  707. bool VimEditingEngine::on_key_in_normal_mode(const KeyEvent& event)
  708. {
  709. // Ignore auxiliary keypress events.
  710. if (event.key() == KeyCode::Key_LeftShift
  711. || event.key() == KeyCode::Key_RightShift
  712. || event.key() == KeyCode::Key_Control
  713. || event.key() == KeyCode::Key_Alt) {
  714. return false;
  715. }
  716. if (m_previous_key == KeyCode::Key_D) {
  717. if (event.key() == KeyCode::Key_D && !m_motion.should_consume_next_character()) {
  718. if (m_motion.amount()) {
  719. auto range = m_motion.get_repeat_range(*this, VimMotion::Unit::Line);
  720. VERIFY(range.has_value());
  721. yank(*range, Line);
  722. m_editor->delete_text_range(*range);
  723. } else {
  724. yank(Line);
  725. delete_line();
  726. }
  727. m_motion.reset();
  728. m_previous_key = {};
  729. } else {
  730. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  731. if (m_motion.is_complete()) {
  732. if (!m_motion.is_cancelled()) {
  733. auto range = m_motion.get_range(*this);
  734. VERIFY(range.has_value());
  735. if (range->is_valid()) {
  736. m_editor->delete_text_range(*range);
  737. }
  738. }
  739. m_motion.reset();
  740. m_previous_key = {};
  741. }
  742. }
  743. } else if (m_previous_key == KeyCode::Key_Y) {
  744. if (event.key() == KeyCode::Key_Y && !m_motion.should_consume_next_character()) {
  745. if (m_motion.amount()) {
  746. auto range = m_motion.get_repeat_range(*this, VimMotion::Unit::Line);
  747. VERIFY(range.has_value());
  748. yank(*range, Line);
  749. } else {
  750. yank(Line);
  751. }
  752. m_motion.reset();
  753. m_previous_key = {};
  754. } else {
  755. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  756. if (m_motion.is_complete()) {
  757. if (!m_motion.is_cancelled()) {
  758. auto range = m_motion.get_range(*this);
  759. VERIFY(range.has_value());
  760. if (range->is_valid()) {
  761. m_editor->set_selection(*range);
  762. yank(Selection);
  763. m_editor->clear_selection();
  764. }
  765. }
  766. m_motion.reset();
  767. m_previous_key = {};
  768. }
  769. }
  770. } else if (m_previous_key == KeyCode::Key_C) {
  771. if (event.key() == KeyCode::Key_C && !m_motion.should_consume_next_character()) {
  772. // Needed because the code to replace the deleted line is called after delete_line() so
  773. // what was the second last line before the delete, is now the last line.
  774. bool was_second_last_line = m_editor->cursor().line() == m_editor->line_count() - 2;
  775. yank(Line);
  776. delete_line();
  777. if (was_second_last_line || (m_editor->cursor().line() != 0 && m_editor->cursor().line() != m_editor->line_count() - 1)) {
  778. move_one_up(event);
  779. move_to_logical_line_end();
  780. m_editor->add_code_point(0x0A);
  781. } else if (m_editor->cursor().line() == 0) {
  782. move_to_logical_line_beginning();
  783. m_editor->add_code_point(0x0A);
  784. move_one_up(event);
  785. } else if (m_editor->cursor().line() == m_editor->line_count() - 1) {
  786. m_editor->add_code_point(0x0A);
  787. }
  788. switch_to_insert_mode();
  789. } else {
  790. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  791. if (m_motion.is_complete()) {
  792. if (!m_motion.is_cancelled()) {
  793. auto range = m_motion.get_range(*this);
  794. VERIFY(range.has_value());
  795. if (range->is_valid()) {
  796. m_editor->set_selection(*range);
  797. yank(Selection);
  798. m_editor->delete_text_range(*range);
  799. switch_to_insert_mode();
  800. }
  801. }
  802. m_motion.reset();
  803. m_previous_key = {};
  804. }
  805. }
  806. } else {
  807. if (m_motion.should_consume_next_character()) {
  808. // We must consume the next character.
  809. // FIXME: deduplicate with code below.
  810. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  811. if (m_motion.is_complete()) {
  812. if (!m_motion.is_cancelled()) {
  813. auto maybe_new_position = m_motion.get_position(*this);
  814. if (maybe_new_position.has_value()) {
  815. auto new_position = maybe_new_position.value();
  816. m_editor->set_cursor(new_position);
  817. }
  818. }
  819. m_motion.reset();
  820. }
  821. return true;
  822. }
  823. // Handle first any key codes that are to be applied regardless of modifiers.
  824. switch (event.key()) {
  825. case (KeyCode::Key_Escape):
  826. if (m_editor->on_escape_pressed)
  827. m_editor->on_escape_pressed();
  828. return true;
  829. default:
  830. break;
  831. }
  832. // SHIFT is pressed.
  833. if (event.shift() && !event.ctrl() && !event.alt()) {
  834. switch (event.key()) {
  835. case (KeyCode::Key_A):
  836. move_to_logical_line_end();
  837. switch_to_insert_mode();
  838. return true;
  839. case (KeyCode::Key_I):
  840. move_to_logical_line_beginning();
  841. switch_to_insert_mode();
  842. return true;
  843. case (KeyCode::Key_O):
  844. move_to_logical_line_beginning();
  845. m_editor->add_code_point(0x0A);
  846. move_one_up(event);
  847. switch_to_insert_mode();
  848. return true;
  849. // FIXME: Integrate these into vim motions too.
  850. case (KeyCode::Key_LeftBrace):
  851. move_to_previous_empty_lines_block();
  852. return true;
  853. case (KeyCode::Key_RightBrace):
  854. move_to_next_empty_lines_block();
  855. return true;
  856. case (KeyCode::Key_J): {
  857. // Looks a bit strange, but join without a repeat, with 1 as the repeat or 2 as the repeat all join the current and next lines
  858. auto amount = (m_motion.amount() > 2) ? (m_motion.amount() - 1) : 1;
  859. m_motion.reset();
  860. for (int i = 0; i < amount; i++) {
  861. if (m_editor->cursor().line() + 1 >= m_editor->line_count())
  862. return true;
  863. move_to_logical_line_end();
  864. m_editor->add_code_point(' ');
  865. TextPosition next_line = { m_editor->cursor().line() + 1, 0 };
  866. m_editor->delete_text_range({ m_editor->cursor(), next_line });
  867. move_one_left();
  868. }
  869. return true;
  870. }
  871. case (KeyCode::Key_P):
  872. put_before();
  873. break;
  874. default:
  875. break;
  876. }
  877. }
  878. // CTRL is pressed.
  879. if (event.ctrl() && !event.shift() && !event.alt()) {
  880. switch (event.key()) {
  881. case (KeyCode::Key_D):
  882. move_half_page_down();
  883. return true;
  884. case (KeyCode::Key_R):
  885. m_editor->redo();
  886. return true;
  887. case (KeyCode::Key_U):
  888. move_half_page_up();
  889. return true;
  890. default:
  891. break;
  892. }
  893. }
  894. // FIXME: H and L movement keys will move to the previous or next line when reaching the beginning or end
  895. // of the line and pressed again.
  896. // No modifier is pressed.
  897. if (!event.ctrl() && !event.shift() && !event.alt()) {
  898. switch (event.key()) {
  899. case (KeyCode::Key_A):
  900. move_one_right();
  901. switch_to_insert_mode();
  902. return true;
  903. case (KeyCode::Key_C):
  904. m_previous_key = event.key();
  905. return true;
  906. case (KeyCode::Key_D):
  907. m_previous_key = event.key();
  908. return true;
  909. case (KeyCode::Key_I):
  910. switch_to_insert_mode();
  911. return true;
  912. case (KeyCode::Key_O):
  913. move_to_logical_line_end();
  914. m_editor->add_code_point(0x0A);
  915. switch_to_insert_mode();
  916. return true;
  917. case (KeyCode::Key_U):
  918. m_editor->undo();
  919. return true;
  920. case (KeyCode::Key_X): {
  921. TextRange range = { m_editor->cursor(), { m_editor->cursor().line(), m_editor->cursor().column() + 1 } };
  922. if (m_motion.amount()) {
  923. auto opt = m_motion.get_repeat_range(*this, VimMotion::Unit::Character);
  924. VERIFY(opt.has_value());
  925. range = *opt;
  926. m_motion.reset();
  927. }
  928. yank(range, Selection);
  929. m_editor->delete_text_range(range);
  930. return true;
  931. }
  932. case (KeyCode::Key_V):
  933. switch_to_visual_mode();
  934. return true;
  935. case (KeyCode::Key_Y):
  936. m_previous_key = event.key();
  937. return true;
  938. case (KeyCode::Key_P):
  939. put_after();
  940. return true;
  941. case (KeyCode::Key_PageUp):
  942. move_page_up();
  943. return true;
  944. case (KeyCode::Key_PageDown):
  945. move_page_down();
  946. return true;
  947. default:
  948. break;
  949. }
  950. }
  951. // If nothing else handled the key, we'll be feeding the motion state
  952. // machine instead.
  953. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  954. if (m_motion.is_complete()) {
  955. if (!m_motion.is_cancelled()) {
  956. auto maybe_new_position = m_motion.get_position(*this);
  957. if (maybe_new_position.has_value()) {
  958. auto new_position = maybe_new_position.value();
  959. m_editor->set_cursor(new_position);
  960. }
  961. }
  962. m_motion.reset();
  963. }
  964. }
  965. return true;
  966. }
  967. bool VimEditingEngine::on_key_in_visual_mode(const KeyEvent& event)
  968. {
  969. // If the motion state machine requires the next character, feed it.
  970. if (m_motion.should_consume_next_character()) {
  971. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  972. if (m_motion.is_complete()) {
  973. if (!m_motion.is_cancelled()) {
  974. auto maybe_new_position = m_motion.get_position(*this, true);
  975. if (maybe_new_position.has_value()) {
  976. auto new_position = maybe_new_position.value();
  977. m_editor->set_cursor(new_position);
  978. update_selection_on_cursor_move();
  979. }
  980. }
  981. m_motion.reset();
  982. }
  983. return true;
  984. }
  985. // Handle first any key codes that are to be applied regardless of modifiers.
  986. switch (event.key()) {
  987. case (KeyCode::Key_Escape):
  988. switch_to_normal_mode();
  989. if (m_editor->on_escape_pressed)
  990. m_editor->on_escape_pressed();
  991. return true;
  992. default:
  993. break;
  994. }
  995. // SHIFT is pressed.
  996. if (event.shift() && !event.ctrl() && !event.alt()) {
  997. switch (event.key()) {
  998. case (KeyCode::Key_A):
  999. move_to_logical_line_end();
  1000. switch_to_insert_mode();
  1001. return true;
  1002. case (KeyCode::Key_I):
  1003. move_to_logical_line_beginning();
  1004. switch_to_insert_mode();
  1005. return true;
  1006. default:
  1007. break;
  1008. }
  1009. }
  1010. // CTRL is pressed.
  1011. if (event.ctrl() && !event.shift() && !event.alt()) {
  1012. switch (event.key()) {
  1013. case (KeyCode::Key_D):
  1014. move_half_page_down();
  1015. update_selection_on_cursor_move();
  1016. return true;
  1017. case (KeyCode::Key_U):
  1018. move_half_page_up();
  1019. update_selection_on_cursor_move();
  1020. return true;
  1021. default:
  1022. break;
  1023. }
  1024. }
  1025. // No modifier is pressed.
  1026. if (!event.ctrl() && !event.shift() && !event.alt()) {
  1027. switch (event.key()) {
  1028. case (KeyCode::Key_D):
  1029. yank(Selection);
  1030. m_editor->do_delete();
  1031. switch_to_normal_mode();
  1032. return true;
  1033. case (KeyCode::Key_U):
  1034. // FIXME: Set selection to uppercase.
  1035. return true;
  1036. case (KeyCode::Key_X):
  1037. yank(Selection);
  1038. m_editor->do_delete();
  1039. switch_to_normal_mode();
  1040. return true;
  1041. case (KeyCode::Key_V):
  1042. switch_to_normal_mode();
  1043. return true;
  1044. case (KeyCode::Key_C):
  1045. yank(Selection);
  1046. m_editor->do_delete();
  1047. switch_to_insert_mode();
  1048. return true;
  1049. case (KeyCode::Key_Y):
  1050. yank(Selection);
  1051. switch_to_normal_mode();
  1052. return true;
  1053. case (KeyCode::Key_PageUp):
  1054. move_page_up();
  1055. update_selection_on_cursor_move();
  1056. return true;
  1057. case (KeyCode::Key_PageDown):
  1058. move_page_down();
  1059. update_selection_on_cursor_move();
  1060. return true;
  1061. default:
  1062. break;
  1063. }
  1064. }
  1065. // By default, we feed the motion state machine.
  1066. m_motion.add_key_code(event.key(), event.ctrl(), event.shift(), event.alt());
  1067. if (m_motion.is_complete()) {
  1068. if (!m_motion.is_cancelled()) {
  1069. auto maybe_new_position = m_motion.get_position(*this, true);
  1070. if (maybe_new_position.has_value()) {
  1071. auto new_position = maybe_new_position.value();
  1072. m_editor->set_cursor(new_position);
  1073. update_selection_on_cursor_move();
  1074. }
  1075. }
  1076. m_motion.reset();
  1077. }
  1078. return true;
  1079. }
  1080. void VimEditingEngine::switch_to_normal_mode()
  1081. {
  1082. m_vim_mode = VimMode::Normal;
  1083. m_editor->reset_cursor_blink();
  1084. m_previous_key = {};
  1085. clear_visual_mode_data();
  1086. m_motion.reset();
  1087. };
  1088. void VimEditingEngine::switch_to_insert_mode()
  1089. {
  1090. m_vim_mode = VimMode::Insert;
  1091. m_editor->reset_cursor_blink();
  1092. m_previous_key = {};
  1093. clear_visual_mode_data();
  1094. m_motion.reset();
  1095. };
  1096. void VimEditingEngine::switch_to_visual_mode()
  1097. {
  1098. m_vim_mode = VimMode::Visual;
  1099. m_editor->reset_cursor_blink();
  1100. m_previous_key = {};
  1101. m_selection_start_position = m_editor->cursor();
  1102. m_editor->selection()->set(m_editor->cursor(), { m_editor->cursor().line(), m_editor->cursor().column() + 1 });
  1103. m_editor->did_update_selection();
  1104. m_motion.reset();
  1105. }
  1106. void VimEditingEngine::update_selection_on_cursor_move()
  1107. {
  1108. auto cursor = m_editor->cursor();
  1109. auto start = m_selection_start_position < cursor ? m_selection_start_position : cursor;
  1110. auto end = m_selection_start_position < cursor ? cursor : m_selection_start_position;
  1111. if (end.column() >= m_editor->current_line().length()) {
  1112. if (end.line() != m_editor->line_count() - 1)
  1113. end = { end.line() + 1, 0 };
  1114. } else {
  1115. end.set_column(end.column() + 1);
  1116. }
  1117. m_editor->selection()->set(start, end);
  1118. m_editor->did_update_selection();
  1119. }
  1120. void VimEditingEngine::clamp_cursor_position()
  1121. {
  1122. auto cursor = m_editor->cursor();
  1123. if (cursor.column() >= m_editor->current_line().length()) {
  1124. cursor.set_column(m_editor->current_line().length() - 1);
  1125. m_editor->set_cursor(cursor);
  1126. }
  1127. }
  1128. void VimEditingEngine::clear_visual_mode_data()
  1129. {
  1130. if (m_editor->has_selection()) {
  1131. m_editor->selection()->clear();
  1132. m_editor->did_update_selection();
  1133. clamp_cursor_position();
  1134. }
  1135. m_selection_start_position = {};
  1136. }
  1137. void VimEditingEngine::move_half_page_up()
  1138. {
  1139. move_up(0.5);
  1140. };
  1141. void VimEditingEngine::move_half_page_down()
  1142. {
  1143. move_down(0.5);
  1144. };
  1145. void VimEditingEngine::yank(YankType type)
  1146. {
  1147. m_yank_type = type;
  1148. if (type == YankType::Line) {
  1149. m_yank_buffer = m_editor->current_line().to_utf8();
  1150. } else {
  1151. m_yank_buffer = m_editor->selected_text();
  1152. }
  1153. // When putting this, auto indentation (if enabled) will indent as far as
  1154. // is necessary, then any whitespace captured before the yanked text will be placed
  1155. // after the indentation, doubling the indentation.
  1156. if (m_editor->is_automatic_indentation_enabled())
  1157. m_yank_buffer = m_yank_buffer.trim_whitespace(TrimMode::Left);
  1158. }
  1159. void VimEditingEngine::yank(TextRange range, YankType yank_type)
  1160. {
  1161. m_yank_type = yank_type;
  1162. m_yank_buffer = m_editor->document().text_in_range(range).trim_whitespace(AK::TrimMode::Right);
  1163. }
  1164. void VimEditingEngine::put_before()
  1165. {
  1166. auto amount = m_motion.amount() ? m_motion.amount() : 1;
  1167. m_motion.reset();
  1168. if (m_yank_type == YankType::Line) {
  1169. move_to_logical_line_beginning();
  1170. StringBuilder sb = StringBuilder(amount * (m_yank_buffer.length() + 1));
  1171. for (auto i = 0; i < amount; i++) {
  1172. sb.append(m_yank_buffer);
  1173. sb.append_code_point(0x0A);
  1174. }
  1175. m_editor->insert_at_cursor_or_replace_selection(sb.to_string());
  1176. m_editor->set_cursor({ m_editor->cursor().line(), m_editor->current_line().first_non_whitespace_column() });
  1177. } else {
  1178. StringBuilder sb = StringBuilder(m_yank_buffer.length() * amount);
  1179. for (auto i = 0; i < amount; i++) {
  1180. sb.append(m_yank_buffer);
  1181. }
  1182. m_editor->insert_at_cursor_or_replace_selection(sb.to_string());
  1183. move_one_left();
  1184. }
  1185. }
  1186. void VimEditingEngine::put_after()
  1187. {
  1188. auto amount = m_motion.amount() ? m_motion.amount() : 1;
  1189. m_motion.reset();
  1190. if (m_yank_type == YankType::Line) {
  1191. move_to_logical_line_end();
  1192. StringBuilder sb = StringBuilder(m_yank_buffer.length() + 1);
  1193. for (auto i = 0; i < amount; i++) {
  1194. sb.append_code_point(0x0A);
  1195. sb.append(m_yank_buffer);
  1196. }
  1197. m_editor->insert_at_cursor_or_replace_selection(sb.to_string());
  1198. m_editor->set_cursor({ m_editor->cursor().line(), m_editor->current_line().first_non_whitespace_column() });
  1199. } else {
  1200. // FIXME: If attempting to put on the last column a line,
  1201. // the buffer will bne placed on the next line due to the move_one_left/right behaviour.
  1202. move_one_right();
  1203. StringBuilder sb = StringBuilder(m_yank_buffer.length() * amount);
  1204. for (auto i = 0; i < amount; i++) {
  1205. sb.append(m_yank_buffer);
  1206. }
  1207. m_editor->insert_at_cursor_or_replace_selection(sb.to_string());
  1208. move_one_left();
  1209. }
  1210. }
  1211. void VimEditingEngine::move_to_previous_empty_lines_block()
  1212. {
  1213. VERIFY(!m_editor.is_null());
  1214. size_t line_idx = m_editor->cursor().line();
  1215. bool skipping_initial_empty_lines = true;
  1216. while (line_idx > 0) {
  1217. if (m_editor->document().line(line_idx).is_empty()) {
  1218. if (!skipping_initial_empty_lines)
  1219. break;
  1220. } else {
  1221. skipping_initial_empty_lines = false;
  1222. }
  1223. line_idx--;
  1224. }
  1225. TextPosition new_cursor = { line_idx, 0 };
  1226. m_editor->set_cursor(new_cursor);
  1227. };
  1228. void VimEditingEngine::move_to_next_empty_lines_block()
  1229. {
  1230. VERIFY(!m_editor.is_null());
  1231. size_t line_idx = m_editor->cursor().line();
  1232. bool skipping_initial_empty_lines = true;
  1233. while (line_idx < m_editor->line_count() - 1) {
  1234. if (m_editor->document().line(line_idx).is_empty()) {
  1235. if (!skipping_initial_empty_lines)
  1236. break;
  1237. } else {
  1238. skipping_initial_empty_lines = false;
  1239. }
  1240. line_idx++;
  1241. }
  1242. TextPosition new_cursor = { line_idx, 0 };
  1243. m_editor->set_cursor(new_cursor);
  1244. };
  1245. }