a694533bf6df0ed3ee4d6e694f0d1b507deab7a3
[nikiroo-utils.git] / TEditorWidget.java
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 */
29 package jexer;
30
31 import java.io.IOException;
32
33 import jexer.bits.CellAttributes;
34 import jexer.event.TKeypressEvent;
35 import jexer.event.TMouseEvent;
36 import jexer.event.TResizeEvent;
37 import jexer.teditor.Document;
38 import jexer.teditor.Line;
39 import jexer.teditor.Word;
40 import static jexer.TKeypress.*;
41
42 /**
43 * TEditorWidget displays an editable text document. It is unaware of
44 * scrolling behavior, but can respond to mouse and keyboard events.
45 */
46 public class TEditorWidget extends TWidget {
47
48 // ------------------------------------------------------------------------
49 // Constants --------------------------------------------------------------
50 // ------------------------------------------------------------------------
51
52 /**
53 * The number of lines to scroll on mouse wheel up/down.
54 */
55 private static final int wheelScrollSize = 3;
56
57 // ------------------------------------------------------------------------
58 // Variables --------------------------------------------------------------
59 // ------------------------------------------------------------------------
60
61 /**
62 * The document being edited.
63 */
64 private Document document;
65
66 /**
67 * The default color for the TEditor class.
68 */
69 private CellAttributes defaultColor = null;
70
71 /**
72 * The topmost line number in the visible area. 0-based.
73 */
74 private int topLine = 0;
75
76 /**
77 * The leftmost column number in the visible area. 0-based.
78 */
79 private int leftColumn = 0;
80
81 // ------------------------------------------------------------------------
82 // Constructors -----------------------------------------------------------
83 // ------------------------------------------------------------------------
84
85 /**
86 * Public constructor.
87 *
88 * @param parent parent widget
89 * @param text text on the screen
90 * @param x column relative to parent
91 * @param y row relative to parent
92 * @param width width of text area
93 * @param height height of text area
94 */
95 public TEditorWidget(final TWidget parent, final String text, final int x,
96 final int y, final int width, final int height) {
97
98 // Set parent and window
99 super(parent, x, y, width, height);
100
101 setCursorVisible(true);
102
103 defaultColor = getTheme().getColor("teditor");
104 document = new Document(text, defaultColor);
105 }
106
107 // ------------------------------------------------------------------------
108 // TWidget ----------------------------------------------------------------
109 // ------------------------------------------------------------------------
110
111 /**
112 * Draw the text box.
113 */
114 @Override
115 public void draw() {
116 for (int i = 0; i < getHeight(); i++) {
117 // Background line
118 getScreen().hLineXY(0, i, getWidth(), ' ', defaultColor);
119
120 // Now draw document's line
121 if (topLine + i < document.getLineCount()) {
122 Line line = document.getLine(topLine + i);
123 int x = 0;
124 for (Word word: line.getWords()) {
125 // For now, we are cheating: draw outside the left region
126 // if needed and let screen do the clipping.
127 getScreen().putStringXY(x - leftColumn, i, word.getText(),
128 word.getColor());
129 x += word.getDisplayLength();
130 if (x - leftColumn > getWidth()) {
131 break;
132 }
133 }
134 }
135 }
136 }
137
138 /**
139 * Handle mouse press events.
140 *
141 * @param mouse mouse button press event
142 */
143 @Override
144 public void onMouseDown(final TMouseEvent mouse) {
145 if (mouse.isMouseWheelUp()) {
146 for (int i = 0; i < wheelScrollSize; i++) {
147 if (topLine > 0) {
148 topLine--;
149 alignDocument(false);
150 }
151 }
152 return;
153 }
154 if (mouse.isMouseWheelDown()) {
155 for (int i = 0; i < wheelScrollSize; i++) {
156 if (topLine < document.getLineCount() - 1) {
157 topLine++;
158 alignDocument(true);
159 }
160 }
161 return;
162 }
163
164 if (mouse.isMouse1()) {
165 // Set the row and column
166 int newLine = topLine + mouse.getY();
167 int newX = leftColumn + mouse.getX();
168 if (newLine > document.getLineCount() - 1) {
169 // Go to the end
170 document.setLineNumber(document.getLineCount() - 1);
171 document.end();
172 if (newLine > document.getLineCount() - 1) {
173 setCursorY(document.getLineCount() - 1 - topLine);
174 } else {
175 setCursorY(mouse.getY());
176 }
177 alignCursor();
178 return;
179 }
180
181 document.setLineNumber(newLine);
182 setCursorY(mouse.getY());
183 if (newX >= document.getCurrentLine().getDisplayLength()) {
184 document.end();
185 alignCursor();
186 } else {
187 document.setCursor(newX);
188 setCursorX(mouse.getX());
189 }
190 return;
191 }
192
193 // Pass to children
194 super.onMouseDown(mouse);
195 }
196
197 /**
198 * Handle keystrokes.
199 *
200 * @param keypress keystroke event
201 */
202 @Override
203 public void onKeypress(final TKeypressEvent keypress) {
204 if (keypress.equals(kbLeft)) {
205 document.left();
206 alignTopLine(false);
207 } else if (keypress.equals(kbRight)) {
208 document.right();
209 alignTopLine(true);
210 } else if (keypress.equals(kbAltLeft)
211 || keypress.equals(kbCtrlLeft)
212 ) {
213 document.backwardsWord();
214 alignTopLine(false);
215 } else if (keypress.equals(kbAltRight)
216 || keypress.equals(kbCtrlRight)
217 ) {
218 document.forwardsWord();
219 alignTopLine(true);
220 } else if (keypress.equals(kbUp)) {
221 document.up();
222 alignTopLine(false);
223 } else if (keypress.equals(kbDown)) {
224 document.down();
225 alignTopLine(true);
226 } else if (keypress.equals(kbPgUp)) {
227 document.up(getHeight() - 1);
228 alignTopLine(false);
229 } else if (keypress.equals(kbPgDn)) {
230 document.down(getHeight() - 1);
231 alignTopLine(true);
232 } else if (keypress.equals(kbHome)) {
233 if (document.home()) {
234 leftColumn = 0;
235 if (leftColumn < 0) {
236 leftColumn = 0;
237 }
238 setCursorX(0);
239 }
240 } else if (keypress.equals(kbEnd)) {
241 if (document.end()) {
242 alignCursor();
243 }
244 } else if (keypress.equals(kbCtrlHome)) {
245 document.setLineNumber(0);
246 document.home();
247 topLine = 0;
248 leftColumn = 0;
249 setCursorX(0);
250 setCursorY(0);
251 } else if (keypress.equals(kbCtrlEnd)) {
252 document.setLineNumber(document.getLineCount() - 1);
253 document.end();
254 alignTopLine(false);
255 } else if (keypress.equals(kbIns)) {
256 document.setOverwrite(!document.getOverwrite());
257 } else if (keypress.equals(kbDel)) {
258 document.del();
259 alignCursor();
260 } else if (keypress.equals(kbBackspace)
261 || keypress.equals(kbBackspaceDel)
262 ) {
263 document.backspace();
264 alignTopLine(false);
265 } else if (keypress.equals(kbTab)) {
266 // TODO: tab character. For now just add spaces until we hit
267 // modulo 8.
268 for (int i = document.getCursor(); (i + 1) % 8 != 0; i++) {
269 document.addChar(' ');
270 }
271 alignCursor();
272 } else if (keypress.equals(kbEnter)) {
273 document.enter();
274 alignTopLine(true);
275 } else if (!keypress.getKey().isFnKey()
276 && !keypress.getKey().isAlt()
277 && !keypress.getKey().isCtrl()
278 ) {
279 // Plain old keystroke, process it
280 document.addChar(keypress.getKey().getChar());
281 alignCursor();
282 } else {
283 // Pass other keys (tab etc.) on to TWidget
284 super.onKeypress(keypress);
285 }
286 }
287
288 /**
289 * Method that subclasses can override to handle window/screen resize
290 * events.
291 *
292 * @param resize resize event
293 */
294 @Override
295 public void onResize(final TResizeEvent resize) {
296 // Change my width/height, and pull the cursor in as needed.
297 if (resize.getType() == TResizeEvent.Type.WIDGET) {
298 setWidth(resize.getWidth());
299 setHeight(resize.getHeight());
300 // See if the cursor is now outside the window, and if so move
301 // things.
302 if (getCursorX() >= getWidth()) {
303 leftColumn += getCursorX() - (getWidth() - 1);
304 setCursorX(getWidth() - 1);
305 }
306 if (getCursorY() >= getHeight()) {
307 topLine += getCursorY() - (getHeight() - 1);
308 setCursorY(getHeight() - 1);
309 }
310 } else {
311 // Let superclass handle it
312 super.onResize(resize);
313 }
314 }
315
316 // ------------------------------------------------------------------------
317 // TEditorWidget ----------------------------------------------------------
318 // ------------------------------------------------------------------------
319
320 /**
321 * Align visible area with document current line.
322 *
323 * @param topLineIsTop if true, make the top visible line the document
324 * current line if it was off-screen. If false, make the bottom visible
325 * line the document current line.
326 */
327 private void alignTopLine(final boolean topLineIsTop) {
328 int line = document.getLineNumber();
329
330 if ((line < topLine) || (line > topLine + getHeight() - 1)) {
331 // Need to move topLine to bring document back into view.
332 if (topLineIsTop) {
333 topLine = line - (getHeight() - 1);
334 if (topLine < 0) {
335 topLine = 0;
336 }
337 assert (topLine >= 0);
338 } else {
339 topLine = line;
340 assert (topLine >= 0);
341 }
342 }
343
344 /*
345 System.err.println("line " + line + " topLine " + topLine);
346 */
347
348 // Document is in view, let's set cursorY
349 assert (line >= topLine);
350 setCursorY(line - topLine);
351 alignCursor();
352 }
353
354 /**
355 * Align document current line with visible area.
356 *
357 * @param topLineIsTop if true, make the top visible line the document
358 * current line if it was off-screen. If false, make the bottom visible
359 * line the document current line.
360 */
361 private void alignDocument(final boolean topLineIsTop) {
362 int line = document.getLineNumber();
363 int cursor = document.getCursor();
364
365 if ((line < topLine) || (line > topLine + getHeight() - 1)) {
366 // Need to move document to ensure it fits view.
367 if (topLineIsTop) {
368 document.setLineNumber(topLine);
369 } else {
370 document.setLineNumber(topLine + (getHeight() - 1));
371 }
372 if (cursor < document.getCurrentLine().getDisplayLength()) {
373 document.setCursor(cursor);
374 }
375 }
376
377 /*
378 System.err.println("getLineNumber() " + document.getLineNumber() +
379 " topLine " + topLine);
380 */
381
382 // Document is in view, let's set cursorY
383 setCursorY(document.getLineNumber() - topLine);
384 alignCursor();
385 }
386
387 /**
388 * Align visible cursor with document cursor.
389 */
390 private void alignCursor() {
391 int width = getWidth();
392
393 int desiredX = document.getCursor() - leftColumn;
394 if (desiredX < 0) {
395 // We need to push the screen to the left.
396 leftColumn = document.getCursor();
397 } else if (desiredX > width - 1) {
398 // We need to push the screen to the right.
399 leftColumn = document.getCursor() - (width - 1);
400 }
401
402 /*
403 System.err.println("document cursor " + document.getCursor() +
404 " leftColumn " + leftColumn);
405 */
406
407
408 setCursorX(document.getCursor() - leftColumn);
409 }
410
411 /**
412 * Get the number of lines in the underlying Document.
413 *
414 * @return the number of lines
415 */
416 public int getLineCount() {
417 return document.getLineCount();
418 }
419
420 /**
421 * Get the current visible top row number. 1-based.
422 *
423 * @return the visible top row number. Row 1 is the first row.
424 */
425 public int getVisibleRowNumber() {
426 return topLine + 1;
427 }
428
429 /**
430 * Set the current visible row number. 1-based.
431 *
432 * @param row the new visible row number. Row 1 is the first row.
433 */
434 public void setVisibleRowNumber(final int row) {
435 assert (row > 0);
436 if ((row > 0) && (row < document.getLineCount())) {
437 topLine = row - 1;
438 alignDocument(true);
439 }
440 }
441
442 /**
443 * Get the current editing row number. 1-based.
444 *
445 * @return the editing row number. Row 1 is the first row.
446 */
447 public int getEditingRowNumber() {
448 return document.getLineNumber() + 1;
449 }
450
451 /**
452 * Set the current editing row number. 1-based.
453 *
454 * @param row the new editing row number. Row 1 is the first row.
455 */
456 public void setEditingRowNumber(final int row) {
457 assert (row > 0);
458 if ((row > 0) && (row < document.getLineCount())) {
459 document.setLineNumber(row - 1);
460 alignTopLine(true);
461 }
462 }
463
464 /**
465 * Set the current visible column number. 1-based.
466 *
467 * @return the visible column number. Column 1 is the first column.
468 */
469 public int getVisibleColumnNumber() {
470 return leftColumn + 1;
471 }
472
473 /**
474 * Set the current visible column number. 1-based.
475 *
476 * @param column the new visible column number. Column 1 is the first
477 * column.
478 */
479 public void setVisibleColumnNumber(final int column) {
480 assert (column > 0);
481 if ((column > 0) && (column < document.getLineLengthMax())) {
482 leftColumn = column - 1;
483 alignDocument(true);
484 }
485 }
486
487 /**
488 * Get the current editing column number. 1-based.
489 *
490 * @return the editing column number. Column 1 is the first column.
491 */
492 public int getEditingColumnNumber() {
493 return document.getCursor() + 1;
494 }
495
496 /**
497 * Set the current editing column number. 1-based.
498 *
499 * @param column the new editing column number. Column 1 is the first
500 * column.
501 */
502 public void setEditingColumnNumber(final int column) {
503 if ((column > 0) && (column < document.getLineLength())) {
504 document.setCursor(column - 1);
505 alignCursor();
506 }
507 }
508
509 /**
510 * Get the maximum possible row number. 1-based.
511 *
512 * @return the maximum row number. Row 1 is the first row.
513 */
514 public int getMaximumRowNumber() {
515 return document.getLineCount() + 1;
516 }
517
518 /**
519 * Get the maximum possible column number. 1-based.
520 *
521 * @return the maximum column number. Column 1 is the first column.
522 */
523 public int getMaximumColumnNumber() {
524 return document.getLineLengthMax() + 1;
525 }
526
527 /**
528 * Get the dirty value.
529 *
530 * @return true if the buffer is dirty
531 */
532 public boolean isDirty() {
533 return document.isDirty();
534 }
535
536 /**
537 * Save contents to file.
538 *
539 * @param filename file to save to
540 * @throws IOException if a java.io operation throws
541 */
542 public void saveToFilename(final String filename) throws IOException {
543 document.saveToFilename(filename);
544 }
545
546 }