#55 restore default attributes on exit
[nikiroo-utils.git] / src / jexer / teditor / Line.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.util.ArrayList;
32import java.util.List;
33
34import jexer.bits.CellAttributes;
35import jexer.bits.StringUtils;
36
37/**
38 * A Line represents a single line of text on the screen, as a collection of
39 * words.
40 */
41public class Line {
42
43 // ------------------------------------------------------------------------
44 // Variables --------------------------------------------------------------
45 // ------------------------------------------------------------------------
46
47 /**
48 * The list of words.
49 */
50 private ArrayList<Word> words = new ArrayList<Word>();
51
52 /**
53 * The default color for the TEditor class.
54 */
55 private CellAttributes defaultColor = null;
56
57 /**
58 * The text highlighter to use.
59 */
60 private Highlighter highlighter = null;
61
62 /**
63 * The current edition position on this line.
64 */
65 private int position = 0;
66
67 /**
68 * The current editing position screen column number.
69 */
70 private int screenPosition = 0;
71
72 /**
73 * The raw text of this line, what is passed to Word to determine
74 * highlighting behavior.
75 */
76 private StringBuilder rawText;
77
78 // ------------------------------------------------------------------------
79 // Constructors -----------------------------------------------------------
80 // ------------------------------------------------------------------------
81
82 /**
83 * Construct a new Line from an existing text string, and highlight
84 * certain strings.
85 *
86 * @param str the text string
87 * @param defaultColor the color for unhighlighted text
88 * @param highlighter the highlighter to use
89 */
90 public Line(final String str, final CellAttributes defaultColor,
91 final Highlighter highlighter) {
92
93 this.defaultColor = defaultColor;
94 this.highlighter = highlighter;
95 this.rawText = new StringBuilder(str);
96
97 scanLine();
98 }
99
100 /**
101 * Construct a new Line from an existing text string.
102 *
103 * @param str the text string
104 * @param defaultColor the color for unhighlighted text
105 */
106 public Line(final String str, final CellAttributes defaultColor) {
107 this(str, defaultColor, null);
108 }
109
110 // ------------------------------------------------------------------------
111 // Line -------------------------------------------------------------------
112 // ------------------------------------------------------------------------
113
114 /**
115 * Get a (shallow) copy of the words in this line.
116 *
117 * @return a copy of the word list
118 */
119 public List<Word> getWords() {
120 return new ArrayList<Word>(words);
121 }
122
123 /**
124 * Get the current cursor position in the text.
125 *
126 * @return the cursor position
127 */
128 public int getRawCursor() {
129 return position;
130 }
131
132 /**
133 * Get the current cursor position on screen.
134 *
135 * @return the cursor position
136 */
137 public int getCursor() {
138 return screenPosition;
139 }
140
141 /**
142 * Set the current cursor position.
143 *
144 * @param cursor the new cursor position
145 */
146 public void setCursor(final int cursor) {
147 if ((cursor < 0)
148 || ((cursor >= getDisplayLength())
149 && (getDisplayLength() > 0))
150 ) {
151 throw new IndexOutOfBoundsException("Max length is " +
152 getDisplayLength() + ", requested position " + cursor);
153 }
154 screenPosition = cursor;
155 position = screenToTextPosition(screenPosition);
156 }
157
158 /**
159 * Get the character at the current cursor position in the text.
160 *
161 * @return the character, or -1 if the cursor is at the end of the line
162 */
163 public int getChar() {
164 if (position == rawText.length()) {
165 return -1;
166 }
167 return rawText.codePointAt(position);
168 }
169
170 /**
171 * Get the on-screen display length.
172 *
173 * @return the number of cells needed to display this line
174 */
175 public int getDisplayLength() {
176 int n = StringUtils.width(rawText.toString());
177
178 if (n > 0) {
179 // If we have any visible characters, add one to the display so
180 // that the position is immediately after the data.
181 return n + 1;
182 }
183 return n;
184 }
185
186 /**
187 * Get the raw string that matches this line.
188 *
189 * @return the string
190 */
191 public String getRawString() {
192 return rawText.toString();
193 }
194
195 /**
196 * Scan rawText and make words out of it.
197 */
198 private void scanLine() {
199 words.clear();
200 Word word = new Word(this.defaultColor, this.highlighter);
201 words.add(word);
202 for (int i = 0; i < rawText.length();) {
203 int ch = rawText.codePointAt(i);
204 i += Character.charCount(ch);
205 Word newWord = word.addChar(ch);
206 if (newWord != word) {
207 words.add(newWord);
208 word = newWord;
209 }
210 }
211 for (Word w: words) {
212 w.applyHighlight();
213 }
214 }
215
216 /**
217 * Decrement the cursor by one. If at the first column, do nothing.
218 *
219 * @return true if the cursor position changed
220 */
221 public boolean left() {
222 if (position == 0) {
223 return false;
224 }
225 screenPosition -= StringUtils.width(rawText.codePointBefore(position));
226 position -= Character.charCount(rawText.codePointBefore(position));
227 return true;
228 }
229
230 /**
231 * Increment the cursor by one. If at the last column, do nothing.
232 *
233 * @return true if the cursor position changed
234 */
235 public boolean right() {
236 if (getDisplayLength() == 0) {
237 return false;
238 }
239 if (position == getDisplayLength() - 1) {
240 return false;
241 }
242 if (position < rawText.length()) {
243 screenPosition += StringUtils.width(rawText.codePointAt(position));
244 position += Character.charCount(rawText.codePointAt(position));
245 }
246 assert (position <= rawText.length());
247 return true;
248 }
249
250 /**
251 * Go to the first column of this line.
252 *
253 * @return true if the cursor position changed
254 */
255 public boolean home() {
256 if (position > 0) {
257 position = 0;
258 screenPosition = 0;
259 return true;
260 }
261 return false;
262 }
263
264 /**
265 * Go to the last column of this line.
266 *
267 * @return true if the cursor position changed
268 */
269 public boolean end() {
270 if (position != getDisplayLength() - 1) {
271 position = rawText.length();
272 screenPosition = StringUtils.width(rawText.toString());
273 return true;
274 }
275 return false;
276 }
277
278 /**
279 * Delete the character under the cursor.
280 */
281 public void del() {
282 assert (words.size() > 0);
283
284 if (position < getDisplayLength()) {
285 int n = Character.charCount(rawText.codePointAt(position));
286 for (int i = 0; i < n; i++) {
287 rawText.deleteCharAt(position);
288 }
289 }
290
291 // Re-scan the line to determine the new word boundaries.
292 scanLine();
293 }
294
295 /**
296 * Delete the character immediately preceeding the cursor.
297 */
298 public void backspace() {
299 if (left()) {
300 del();
301 }
302 }
303
304 /**
305 * Insert a character at the cursor.
306 *
307 * @param ch the character to insert
308 */
309 public void addChar(final int ch) {
310 if (position < getDisplayLength() - 1) {
311 rawText.insert(position, Character.toChars(ch));
312 } else {
313 rawText.append(Character.toChars(ch));
314 }
315 position += Character.charCount(ch);
316 screenPosition += StringUtils.width(ch);
317 scanLine();
318 }
319
320 /**
321 * Replace a character at the cursor.
322 *
323 * @param ch the character to replace
324 */
325 public void replaceChar(final int ch) {
326 if (position < getDisplayLength() - 1) {
327 // Replace character
328 String oldText = rawText.toString();
329 rawText = new StringBuilder(oldText.substring(0, position));
330 rawText.append(Character.toChars(ch));
331 rawText.append(oldText.substring(position + 1));
332 screenPosition += StringUtils.width(rawText.codePointAt(position));
333 position += Character.charCount(ch);
334 } else {
335 rawText.append(Character.toChars(ch));
336 position += Character.charCount(ch);
337 screenPosition += StringUtils.width(ch);
338 }
339 scanLine();
340 }
341
342 /**
343 * Determine string position from screen position.
344 *
345 * @param screenPosition the position on screen
346 * @return the equivalent position in text
347 */
348 protected int screenToTextPosition(final int screenPosition) {
349 if (screenPosition == 0) {
350 return 0;
351 }
352
353 int n = 0;
354 for (int i = 0; i < rawText.length(); i++) {
355 n += StringUtils.width(rawText.codePointAt(i));
356 if (n >= screenPosition) {
357 return i + 1;
358 }
359 }
360 // screenPosition exceeds the available text length.
361 throw new IndexOutOfBoundsException("screenPosition " + screenPosition +
362 " exceeds available text length " + rawText.length());
363 }
364
365}