Commit | Line | Data |
---|---|---|
12b55d76 KL |
1 | /* |
2 | * Jexer - Java Text User Interface | |
3 | * | |
4 | * The MIT License (MIT) | |
5 | * | |
a69ed767 | 6 | * Copyright (C) 2019 Kevin Lamonte |
12b55d76 KL |
7 | * |
8 | * Permission is hereby granted, free of charge, to any person obtaining a | |
9 | * copy of this software and associated documentation files (the "Software"), | |
10 | * to deal in the Software without restriction, including without limitation | |
11 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
12 | * and/or sell copies of the Software, and to permit persons to whom the | |
13 | * Software is furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice and this permission notice shall be included in | |
16 | * all copies or substantial portions of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
23 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
24 | * DEALINGS IN THE SOFTWARE. | |
25 | * | |
26 | * @author Kevin Lamonte [kevin.lamonte@gmail.com] | |
27 | * @version 1 | |
28 | */ | |
29 | package jexer.teditor; | |
30 | ||
71a389c9 KL |
31 | import java.io.FileOutputStream; |
32 | import java.io.IOException; | |
33 | import java.io.OutputStreamWriter; | |
12b55d76 KL |
34 | import java.util.ArrayList; |
35 | import java.util.List; | |
36 | ||
e8a11f98 KL |
37 | import jexer.bits.CellAttributes; |
38 | ||
12b55d76 KL |
39 | /** |
40 | * A Document represents a text file, as a collection of lines. | |
41 | */ | |
42 | public class Document { | |
43 | ||
615a0d99 KL |
44 | // ------------------------------------------------------------------------ |
45 | // Variables -------------------------------------------------------------- | |
46 | // ------------------------------------------------------------------------ | |
47 | ||
12b55d76 KL |
48 | /** |
49 | * The list of lines. | |
50 | */ | |
51 | private ArrayList<Line> lines = new ArrayList<Line>(); | |
52 | ||
53 | /** | |
54 | * The current line number being edited. Note that this is 0-based, the | |
55 | * first line is line number 0. | |
56 | */ | |
57 | private int lineNumber = 0; | |
58 | ||
59 | /** | |
60 | * The overwrite flag. When true, characters overwrite data. | |
61 | */ | |
62 | private boolean overwrite = false; | |
63 | ||
71a389c9 KL |
64 | /** |
65 | * If true, the document has been edited. | |
66 | */ | |
67 | private boolean dirty = false; | |
68 | ||
e8a11f98 KL |
69 | /** |
70 | * The default color for the TEditor class. | |
71 | */ | |
72 | private CellAttributes defaultColor = null; | |
73 | ||
74 | /** | |
75 | * The text highlighter to use. | |
76 | */ | |
77 | private Highlighter highlighter = new Highlighter(); | |
78 | ||
615a0d99 KL |
79 | // ------------------------------------------------------------------------ |
80 | // Constructors ----------------------------------------------------------- | |
81 | // ------------------------------------------------------------------------ | |
82 | ||
83 | /** | |
84 | * Construct a new Document from an existing text string. | |
85 | * | |
86 | * @param str the text string | |
87 | * @param defaultColor the color for unhighlighted text | |
88 | */ | |
89 | public Document(final String str, final CellAttributes defaultColor) { | |
90 | this.defaultColor = defaultColor; | |
91 | ||
92 | // TODO: set different colors based on file extension | |
93 | highlighter.setJavaColors(); | |
94 | ||
95 | String [] rawLines = str.split("\n"); | |
96 | for (int i = 0; i < rawLines.length; i++) { | |
97 | lines.add(new Line(rawLines[i], this.defaultColor, highlighter)); | |
98 | } | |
99 | } | |
100 | ||
101 | // ------------------------------------------------------------------------ | |
102 | // Document --------------------------------------------------------------- | |
103 | // ------------------------------------------------------------------------ | |
104 | ||
12b55d76 KL |
105 | /** |
106 | * Get the overwrite flag. | |
107 | * | |
108 | * @return true if addChar() overwrites data, false if it inserts | |
109 | */ | |
110 | public boolean getOverwrite() { | |
111 | return overwrite; | |
112 | } | |
113 | ||
71a389c9 KL |
114 | /** |
115 | * Get the dirty value. | |
116 | * | |
117 | * @return true if the buffer is dirty | |
118 | */ | |
119 | public boolean isDirty() { | |
120 | return dirty; | |
121 | } | |
122 | ||
123 | /** | |
124 | * Save contents to file. | |
125 | * | |
126 | * @param filename file to save to | |
127 | * @throws IOException if a java.io operation throws | |
128 | */ | |
129 | public void saveToFilename(final String filename) throws IOException { | |
130 | OutputStreamWriter output = null; | |
131 | try { | |
132 | output = new OutputStreamWriter(new FileOutputStream(filename), | |
133 | "UTF-8"); | |
134 | ||
135 | for (Line line: lines) { | |
136 | output.write(line.getRawString()); | |
137 | output.write("\n"); | |
138 | } | |
139 | ||
140 | dirty = false; | |
141 | } | |
142 | finally { | |
143 | if (output != null) { | |
144 | output.close(); | |
145 | } | |
146 | } | |
147 | } | |
148 | ||
12b55d76 KL |
149 | /** |
150 | * Set the overwrite flag. | |
151 | * | |
152 | * @param overwrite true if addChar() should overwrite data, false if it | |
153 | * should insert | |
154 | */ | |
155 | public void setOverwrite(final boolean overwrite) { | |
156 | this.overwrite = overwrite; | |
157 | } | |
158 | ||
159 | /** | |
160 | * Get the current line number being edited. | |
161 | * | |
162 | * @return the line number. Note that this is 0-based: 0 is the first | |
163 | * line. | |
164 | */ | |
165 | public int getLineNumber() { | |
166 | return lineNumber; | |
167 | } | |
168 | ||
e8a11f98 KL |
169 | /** |
170 | * Get the current editing line. | |
171 | * | |
172 | * @return the line | |
173 | */ | |
174 | public Line getCurrentLine() { | |
175 | return lines.get(lineNumber); | |
176 | } | |
177 | ||
12b55d76 KL |
178 | /** |
179 | * Get a specific line by number. | |
180 | * | |
181 | * @param lineNumber the line number. Note that this is 0-based: 0 is | |
182 | * the first line. | |
183 | * @return the line | |
184 | */ | |
185 | public Line getLine(final int lineNumber) { | |
186 | return lines.get(lineNumber); | |
187 | } | |
188 | ||
189 | /** | |
190 | * Set the current line number being edited. | |
191 | * | |
192 | * @param n the line number. Note that this is 0-based: 0 is the first | |
193 | * line. | |
194 | */ | |
195 | public void setLineNumber(final int n) { | |
196 | if ((n < 0) || (n > lines.size())) { | |
e8a11f98 KL |
197 | throw new IndexOutOfBoundsException("Lines array size is " + |
198 | lines.size() + ", requested index " + n); | |
12b55d76 KL |
199 | } |
200 | lineNumber = n; | |
201 | } | |
202 | ||
e8a11f98 KL |
203 | /** |
204 | * Get the current cursor position of the editing line. | |
205 | * | |
206 | * @return the cursor position | |
207 | */ | |
208 | public int getCursor() { | |
209 | return lines.get(lineNumber).getCursor(); | |
210 | } | |
211 | ||
e23989a4 KL |
212 | /** |
213 | * Get the character at the current cursor position in the text. | |
214 | * | |
215 | * @return the character, or -1 if the cursor is at the end of the line | |
216 | */ | |
217 | public int getChar() { | |
218 | return lines.get(lineNumber).getChar(); | |
219 | } | |
220 | ||
71a389c9 KL |
221 | /** |
222 | * Set the current cursor position of the editing line. 0-based. | |
223 | * | |
224 | * @param cursor the new cursor position | |
225 | */ | |
226 | public void setCursor(final int cursor) { | |
4297b49b KL |
227 | if (cursor >= lines.get(lineNumber).getDisplayLength()) { |
228 | lines.get(lineNumber).end(); | |
229 | } else { | |
230 | lines.get(lineNumber).setCursor(cursor); | |
231 | } | |
71a389c9 KL |
232 | } |
233 | ||
12b55d76 KL |
234 | /** |
235 | * Increment the line number by one. If at the last line, do nothing. | |
e8a11f98 KL |
236 | * |
237 | * @return true if the editing line changed | |
12b55d76 | 238 | */ |
e8a11f98 | 239 | public boolean down() { |
12b55d76 | 240 | if (lineNumber < lines.size() - 1) { |
e8a11f98 | 241 | int x = lines.get(lineNumber).getCursor(); |
12b55d76 | 242 | lineNumber++; |
4297b49b | 243 | if (x >= lines.get(lineNumber).getDisplayLength()) { |
e8a11f98 KL |
244 | lines.get(lineNumber).end(); |
245 | } else { | |
246 | lines.get(lineNumber).setCursor(x); | |
247 | } | |
248 | return true; | |
12b55d76 | 249 | } |
e8a11f98 | 250 | return false; |
12b55d76 KL |
251 | } |
252 | ||
253 | /** | |
254 | * Increment the line number by n. If n would go past the last line, | |
255 | * increment only to the last line. | |
256 | * | |
257 | * @param n the number of lines to increment by | |
e8a11f98 | 258 | * @return true if the editing line changed |
12b55d76 | 259 | */ |
e8a11f98 KL |
260 | public boolean down(final int n) { |
261 | if (lineNumber < lines.size() - 1) { | |
262 | int x = lines.get(lineNumber).getCursor(); | |
263 | lineNumber += n; | |
264 | if (lineNumber > lines.size() - 1) { | |
265 | lineNumber = lines.size() - 1; | |
266 | } | |
4297b49b | 267 | if (x >= lines.get(lineNumber).getDisplayLength()) { |
e8a11f98 KL |
268 | lines.get(lineNumber).end(); |
269 | } else { | |
270 | lines.get(lineNumber).setCursor(x); | |
271 | } | |
272 | return true; | |
12b55d76 | 273 | } |
e8a11f98 | 274 | return false; |
12b55d76 KL |
275 | } |
276 | ||
277 | /** | |
278 | * Decrement the line number by one. If at the first line, do nothing. | |
e8a11f98 KL |
279 | * |
280 | * @return true if the editing line changed | |
12b55d76 | 281 | */ |
e8a11f98 | 282 | public boolean up() { |
12b55d76 | 283 | if (lineNumber > 0) { |
e8a11f98 | 284 | int x = lines.get(lineNumber).getCursor(); |
12b55d76 | 285 | lineNumber--; |
4297b49b | 286 | if (x >= lines.get(lineNumber).getDisplayLength()) { |
e8a11f98 KL |
287 | lines.get(lineNumber).end(); |
288 | } else { | |
289 | lines.get(lineNumber).setCursor(x); | |
290 | } | |
291 | return true; | |
12b55d76 | 292 | } |
e8a11f98 | 293 | return false; |
12b55d76 KL |
294 | } |
295 | ||
296 | /** | |
297 | * Decrement the line number by n. If n would go past the first line, | |
298 | * decrement only to the first line. | |
299 | * | |
300 | * @param n the number of lines to decrement by | |
e8a11f98 | 301 | * @return true if the editing line changed |
12b55d76 | 302 | */ |
e8a11f98 KL |
303 | public boolean up(final int n) { |
304 | if (lineNumber > 0) { | |
305 | int x = lines.get(lineNumber).getCursor(); | |
306 | lineNumber -= n; | |
307 | if (lineNumber < 0) { | |
308 | lineNumber = 0; | |
309 | } | |
4297b49b | 310 | if (x >= lines.get(lineNumber).getDisplayLength()) { |
e8a11f98 KL |
311 | lines.get(lineNumber).end(); |
312 | } else { | |
313 | lines.get(lineNumber).setCursor(x); | |
314 | } | |
315 | return true; | |
12b55d76 | 316 | } |
e8a11f98 | 317 | return false; |
12b55d76 KL |
318 | } |
319 | ||
320 | /** | |
e23989a4 KL |
321 | * Decrement the cursor by one. If at the first column on the first |
322 | * line, do nothing. | |
e8a11f98 KL |
323 | * |
324 | * @return true if the cursor position changed | |
12b55d76 | 325 | */ |
e8a11f98 | 326 | public boolean left() { |
df602ccf KL |
327 | if (!lines.get(lineNumber).left()) { |
328 | // We are on the leftmost column, wrap | |
329 | if (up()) { | |
330 | end(); | |
331 | } else { | |
332 | return false; | |
333 | } | |
334 | } | |
335 | return true; | |
12b55d76 KL |
336 | } |
337 | ||
338 | /** | |
e23989a4 KL |
339 | * Increment the cursor by one. If at the last column on the last line, |
340 | * do nothing. | |
e8a11f98 KL |
341 | * |
342 | * @return true if the cursor position changed | |
12b55d76 | 343 | */ |
e8a11f98 | 344 | public boolean right() { |
df602ccf KL |
345 | if (!lines.get(lineNumber).right()) { |
346 | // We are on the rightmost column, wrap | |
347 | if (down()) { | |
348 | home(); | |
349 | } else { | |
350 | return false; | |
351 | } | |
352 | } | |
353 | return true; | |
12b55d76 KL |
354 | } |
355 | ||
e23989a4 KL |
356 | /** |
357 | * Go back to the beginning of this word if in the middle, or the | |
358 | * beginning of the previous word. | |
359 | */ | |
360 | public void backwardsWord() { | |
361 | ||
362 | // If at the beginning of a word already, push past it. | |
363 | if ((getChar() != -1) | |
364 | && (getRawLine().length() > 0) | |
365 | && !Character.isSpace((char) getChar()) | |
366 | ) { | |
367 | left(); | |
368 | } | |
369 | ||
370 | // int line = lineNumber; | |
371 | while ((getChar() == -1) | |
372 | || (getRawLine().length() == 0) | |
373 | || Character.isSpace((char) getChar()) | |
374 | ) { | |
375 | if (left() == false) { | |
376 | return; | |
377 | } | |
378 | } | |
379 | ||
380 | ||
381 | assert (getChar() != -1); | |
382 | ||
383 | if (!Character.isSpace((char) getChar()) | |
384 | && (getRawLine().length() > 0) | |
385 | ) { | |
386 | // Advance until at the beginning of the document or a whitespace | |
387 | // is encountered. | |
388 | while (!Character.isSpace((char) getChar())) { | |
389 | int line = lineNumber; | |
390 | if (left() == false) { | |
391 | // End of document, bail out. | |
392 | return; | |
393 | } | |
394 | if (lineNumber != line) { | |
395 | // We wrapped a line. Here that counts as whitespace. | |
396 | right(); | |
397 | return; | |
398 | } | |
399 | } | |
400 | } | |
401 | ||
402 | // We went one past the word, push back to the first character of | |
403 | // that word. | |
404 | right(); | |
405 | return; | |
406 | } | |
407 | ||
408 | /** | |
409 | * Go to the beginning of the next word. | |
410 | */ | |
411 | public void forwardsWord() { | |
412 | int line = lineNumber; | |
413 | while ((getChar() == -1) | |
414 | || (getRawLine().length() == 0) | |
415 | ) { | |
416 | if (right() == false) { | |
417 | return; | |
418 | } | |
419 | if (lineNumber != line) { | |
420 | // We wrapped a line. Here that counts as whitespace. | |
421 | if (!Character.isSpace((char) getChar())) { | |
422 | // We found a character immediately after the line. | |
423 | // Done! | |
424 | return; | |
425 | } | |
426 | // Still looking... | |
427 | line = lineNumber; | |
428 | } | |
429 | } | |
430 | assert (getChar() != -1); | |
431 | ||
432 | if (!Character.isSpace((char) getChar()) | |
433 | && (getRawLine().length() > 0) | |
434 | ) { | |
435 | // Advance until at the end of the document or a whitespace is | |
436 | // encountered. | |
437 | while (!Character.isSpace((char) getChar())) { | |
438 | line = lineNumber; | |
439 | if (right() == false) { | |
440 | // End of document, bail out. | |
441 | return; | |
442 | } | |
443 | if (lineNumber != line) { | |
444 | // We wrapped a line. Here that counts as whitespace. | |
445 | if (!Character.isSpace((char) getChar()) | |
446 | && (getRawLine().length() > 0) | |
447 | ) { | |
448 | // We found a character immediately after the line. | |
449 | // Done! | |
450 | return; | |
451 | } | |
452 | break; | |
453 | } | |
454 | } | |
455 | } | |
456 | ||
457 | while ((getChar() == -1) | |
458 | || (getRawLine().length() == 0) | |
459 | ) { | |
460 | if (right() == false) { | |
461 | return; | |
462 | } | |
463 | if (lineNumber != line) { | |
464 | // We wrapped a line. Here that counts as whitespace. | |
465 | if (!Character.isSpace((char) getChar())) { | |
466 | // We found a character immediately after the line. | |
467 | // Done! | |
468 | return; | |
469 | } | |
470 | // Still looking... | |
471 | line = lineNumber; | |
472 | } | |
473 | } | |
474 | assert (getChar() != -1); | |
475 | ||
476 | if (Character.isSpace((char) getChar())) { | |
477 | // Advance until at the end of the document or a non-whitespace | |
478 | // is encountered. | |
479 | while (Character.isSpace((char) getChar())) { | |
480 | if (right() == false) { | |
481 | // End of document, bail out. | |
482 | return; | |
483 | } | |
484 | } | |
485 | return; | |
486 | } | |
487 | ||
488 | // We wrapped the line to get here. | |
489 | return; | |
490 | } | |
491 | ||
492 | /** | |
493 | * Get the raw string that matches this line. | |
494 | * | |
495 | * @return the string | |
496 | */ | |
497 | public String getRawLine() { | |
498 | return lines.get(lineNumber).getRawString(); | |
499 | } | |
500 | ||
12b55d76 KL |
501 | /** |
502 | * Go to the first column of this line. | |
e8a11f98 KL |
503 | * |
504 | * @return true if the cursor position changed | |
12b55d76 | 505 | */ |
e8a11f98 KL |
506 | public boolean home() { |
507 | return lines.get(lineNumber).home(); | |
12b55d76 KL |
508 | } |
509 | ||
510 | /** | |
511 | * Go to the last column of this line. | |
e8a11f98 KL |
512 | * |
513 | * @return true if the cursor position changed | |
12b55d76 | 514 | */ |
e8a11f98 KL |
515 | public boolean end() { |
516 | return lines.get(lineNumber).end(); | |
12b55d76 KL |
517 | } |
518 | ||
519 | /** | |
520 | * Delete the character under the cursor. | |
521 | */ | |
522 | public void del() { | |
71a389c9 | 523 | dirty = true; |
df602ccf KL |
524 | int cursor = lines.get(lineNumber).getCursor(); |
525 | if (cursor < lines.get(lineNumber).getDisplayLength() - 1) { | |
526 | lines.get(lineNumber).del(); | |
527 | } else if (lineNumber < lines.size() - 2) { | |
528 | // Join two lines | |
529 | StringBuilder newLine = new StringBuilder(lines. | |
530 | get(lineNumber).getRawString()); | |
531 | newLine.append(lines.get(lineNumber + 1).getRawString()); | |
532 | lines.set(lineNumber, new Line(newLine.toString(), | |
533 | defaultColor, highlighter)); | |
534 | lines.get(lineNumber).setCursor(cursor); | |
535 | lines.remove(lineNumber + 1); | |
536 | } | |
12b55d76 KL |
537 | } |
538 | ||
539 | /** | |
540 | * Delete the character immediately preceeding the cursor. | |
541 | */ | |
542 | public void backspace() { | |
71a389c9 | 543 | dirty = true; |
df602ccf KL |
544 | int cursor = lines.get(lineNumber).getCursor(); |
545 | if (cursor > 0) { | |
546 | lines.get(lineNumber).backspace(); | |
547 | } else if (lineNumber > 0) { | |
548 | // Join two lines | |
549 | lineNumber--; | |
550 | String firstLine = lines.get(lineNumber).getRawString(); | |
551 | if (firstLine.length() > 0) { | |
552 | // Backspacing combining two lines | |
553 | StringBuilder newLine = new StringBuilder(firstLine); | |
554 | newLine.append(lines.get(lineNumber + 1).getRawString()); | |
555 | lines.set(lineNumber, new Line(newLine.toString(), | |
556 | defaultColor, highlighter)); | |
557 | lines.get(lineNumber).setCursor(firstLine.length()); | |
558 | lines.remove(lineNumber + 1); | |
559 | } else { | |
560 | // Backspacing an empty line | |
561 | lines.remove(lineNumber); | |
562 | lines.get(lineNumber).setCursor(0); | |
563 | } | |
564 | } | |
565 | } | |
566 | ||
567 | /** | |
568 | * Split the current line into two, like pressing the enter key. | |
569 | */ | |
570 | public void enter() { | |
571 | dirty = true; | |
39e86397 | 572 | int cursor = lines.get(lineNumber).getRawCursor(); |
df602ccf KL |
573 | String original = lines.get(lineNumber).getRawString(); |
574 | String firstLine = original.substring(0, cursor); | |
575 | String secondLine = original.substring(cursor); | |
576 | lines.add(lineNumber + 1, new Line(secondLine, defaultColor, | |
577 | highlighter)); | |
578 | lines.set(lineNumber, new Line(firstLine, defaultColor, highlighter)); | |
579 | lineNumber++; | |
580 | lines.get(lineNumber).home(); | |
12b55d76 KL |
581 | } |
582 | ||
583 | /** | |
584 | * Replace or insert a character at the cursor, depending on overwrite | |
585 | * flag. | |
586 | * | |
587 | * @param ch the character to replace or insert | |
588 | */ | |
2d3f60d8 | 589 | public void addChar(final int ch) { |
71a389c9 | 590 | dirty = true; |
e8a11f98 KL |
591 | if (overwrite) { |
592 | lines.get(lineNumber).replaceChar(ch); | |
593 | } else { | |
594 | lines.get(lineNumber).addChar(ch); | |
595 | } | |
12b55d76 KL |
596 | } |
597 | ||
598 | /** | |
599 | * Get a (shallow) copy of the list of lines. | |
600 | * | |
601 | * @return the list of lines | |
602 | */ | |
603 | public List<Line> getLines() { | |
604 | return new ArrayList<Line>(lines); | |
605 | } | |
606 | ||
607 | /** | |
608 | * Get the number of lines. | |
609 | * | |
610 | * @return the number of lines | |
611 | */ | |
612 | public int getLineCount() { | |
613 | return lines.size(); | |
614 | } | |
615 | ||
616 | /** | |
617 | * Compute the maximum line length for this document. | |
618 | * | |
619 | * @return the number of cells needed to display the longest line | |
620 | */ | |
621 | public int getLineLengthMax() { | |
622 | int n = 0; | |
623 | for (Line line : lines) { | |
624 | if (line.getDisplayLength() > n) { | |
625 | n = line.getDisplayLength(); | |
626 | } | |
627 | } | |
628 | return n; | |
629 | } | |
630 | ||
fe0770f9 KL |
631 | /** |
632 | * Get the current line length. | |
633 | * | |
634 | * @return the number of cells needed to display the current line | |
635 | */ | |
636 | public int getLineLength() { | |
637 | return lines.get(lineNumber).getDisplayLength(); | |
638 | } | |
639 | ||
12b55d76 | 640 | } |