Jexer image protocol performance
[fanfix.git] / src / jexer / teditor / Document.java
... / ...
CommitLineData
1/*
2 * Jexer - Java Text User Interface
3 *
4 * The MIT License (MIT)
5 *
6 * Copyright (C) 2019 Kevin Lamonte
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 */
29package jexer.teditor;
30
31import java.io.FileOutputStream;
32import java.io.IOException;
33import java.io.OutputStreamWriter;
34import java.util.ArrayList;
35import java.util.List;
36
37import jexer.bits.CellAttributes;
38
39/**
40 * A Document represents a text file, as a collection of lines.
41 */
42public class Document {
43
44 // ------------------------------------------------------------------------
45 // Variables --------------------------------------------------------------
46 // ------------------------------------------------------------------------
47
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
64 /**
65 * If true, the document has been edited.
66 */
67 private boolean dirty = false;
68
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
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
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
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
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
169 /**
170 * Get the current editing line.
171 *
172 * @return the line
173 */
174 public Line getCurrentLine() {
175 return lines.get(lineNumber);
176 }
177
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())) {
197 throw new IndexOutOfBoundsException("Lines array size is " +
198 lines.size() + ", requested index " + n);
199 }
200 lineNumber = n;
201 }
202
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
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
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) {
227 if (cursor >= lines.get(lineNumber).getDisplayLength()) {
228 lines.get(lineNumber).end();
229 } else {
230 lines.get(lineNumber).setCursor(cursor);
231 }
232 }
233
234 /**
235 * Increment the line number by one. If at the last line, do nothing.
236 *
237 * @return true if the editing line changed
238 */
239 public boolean down() {
240 if (lineNumber < lines.size() - 1) {
241 int x = lines.get(lineNumber).getCursor();
242 lineNumber++;
243 if (x >= lines.get(lineNumber).getDisplayLength()) {
244 lines.get(lineNumber).end();
245 } else {
246 lines.get(lineNumber).setCursor(x);
247 }
248 return true;
249 }
250 return false;
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
258 * @return true if the editing line changed
259 */
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 }
267 if (x >= lines.get(lineNumber).getDisplayLength()) {
268 lines.get(lineNumber).end();
269 } else {
270 lines.get(lineNumber).setCursor(x);
271 }
272 return true;
273 }
274 return false;
275 }
276
277 /**
278 * Decrement the line number by one. If at the first line, do nothing.
279 *
280 * @return true if the editing line changed
281 */
282 public boolean up() {
283 if (lineNumber > 0) {
284 int x = lines.get(lineNumber).getCursor();
285 lineNumber--;
286 if (x >= lines.get(lineNumber).getDisplayLength()) {
287 lines.get(lineNumber).end();
288 } else {
289 lines.get(lineNumber).setCursor(x);
290 }
291 return true;
292 }
293 return false;
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
301 * @return true if the editing line changed
302 */
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 }
310 if (x >= lines.get(lineNumber).getDisplayLength()) {
311 lines.get(lineNumber).end();
312 } else {
313 lines.get(lineNumber).setCursor(x);
314 }
315 return true;
316 }
317 return false;
318 }
319
320 /**
321 * Decrement the cursor by one. If at the first column on the first
322 * line, do nothing.
323 *
324 * @return true if the cursor position changed
325 */
326 public boolean left() {
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;
336 }
337
338 /**
339 * Increment the cursor by one. If at the last column on the last line,
340 * do nothing.
341 *
342 * @return true if the cursor position changed
343 */
344 public boolean right() {
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;
354 }
355
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.isWhitespace((char) getChar())
366 ) {
367 left();
368 }
369
370 // int line = lineNumber;
371 while ((getChar() == -1)
372 || (getRawLine().length() == 0)
373 || Character.isWhitespace((char) getChar())
374 ) {
375 if (left() == false) {
376 return;
377 }
378 }
379
380
381 assert (getChar() != -1);
382
383 if (!Character.isWhitespace((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.isWhitespace((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.isWhitespace((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.isWhitespace((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.isWhitespace((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.isWhitespace((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.isWhitespace((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.isWhitespace((char) getChar())) {
477 // Advance until at the end of the document or a non-whitespace
478 // is encountered.
479 while (Character.isWhitespace((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
501 /**
502 * Go to the first column of this line.
503 *
504 * @return true if the cursor position changed
505 */
506 public boolean home() {
507 return lines.get(lineNumber).home();
508 }
509
510 /**
511 * Go to the last column of this line.
512 *
513 * @return true if the cursor position changed
514 */
515 public boolean end() {
516 return lines.get(lineNumber).end();
517 }
518
519 /**
520 * Delete the character under the cursor.
521 */
522 public void del() {
523 dirty = true;
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 }
537 }
538
539 /**
540 * Delete the character immediately preceeding the cursor.
541 */
542 public void backspace() {
543 dirty = true;
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;
572 int cursor = lines.get(lineNumber).getRawCursor();
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();
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 */
589 public void addChar(final int ch) {
590 dirty = true;
591 if (overwrite) {
592 lines.get(lineNumber).replaceChar(ch);
593 } else {
594 lines.get(lineNumber).addChar(ch);
595 }
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
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
640}