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