*/
public final class TText extends TWidget {
+ /**
+ * Available text justifications.
+ */
+ public enum Justification {
+ /**
+ * Left-justified text.
+ */
+ LEFT,
+
+ /**
+ * Centered text.
+ */
+ CENTER,
+
+ /**
+ * Right-justified text.
+ */
+ RIGHT,
+
+ /**
+ * Fully-justified text.
+ */
+ FULL,
+ }
+
+ /**
+ * How to justify the text.
+ */
+ private Justification justification = Justification.LEFT;
+
/**
* Text to display.
*/
}
/**
- * Insert newlines into a string to wrap it to a maximum column. Terminate
- * the final string with a newline. Note that interior newlines are
- * converted to spaces.
+ * Set justification.
*
- * @param str the string
- * @param n the maximum number of characters in a line
- * @return the wrapped string
+ * @param justification LEFT, CENTER, RIGHT, or FULL
*/
- private String wrap(final String str, final int n) {
- assert (n > 0);
-
- StringBuilder sb = new StringBuilder();
- StringBuilder word = new StringBuilder();
- int col = 0;
- for (int i = 0; i < str.length(); i++) {
- char ch = str.charAt(i);
- if (ch == '\n') {
- ch = ' ';
- }
- if (ch == ' ') {
- sb.append(word.toString());
- sb.append(ch);
- if (word.length() >= (n - 1)) {
- sb.append('\n');
- col = 0;
- }
- word = new StringBuilder();
- } else {
- word.append(ch);
- }
+ public void setJustification(final Justification justification) {
+ this.justification = justification;
+ reflow();
+ }
- col++;
- if (col >= (n - 1)) {
- sb.append('\n');
- col = 0;
- }
- }
- sb.append(word.toString());
- sb.append('\n');
- return sb.toString();
+ /**
+ * Left-justify the text.
+ */
+ public void leftJustify() {
+ justification = Justification.LEFT;
+ reflow();
+ }
+
+ /**
+ * Center-justify the text.
+ */
+ public void centerJustify() {
+ justification = Justification.CENTER;
+ reflow();
+ }
+
+ /**
+ * Right-justify the text.
+ */
+ public void rightJustify() {
+ justification = Justification.RIGHT;
+ reflow();
+ }
+
+ /**
+ * Fully-justify the text.
+ */
+ public void fullJustify() {
+ justification = Justification.FULL;
+ reflow();
}
/**
// Break up text into paragraphs
String[] paragraphs = text.split("\n\n");
for (String p : paragraphs) {
- String paragraph = wrap(p, getWidth() - 1);
- for (String line : paragraph.split("\n")) {
- lines.add(line);
+ switch (justification) {
+ case LEFT:
+ lines.addAll(jexer.bits.StringJustifier.left(p,
+ getWidth() - 1));
+ break;
+ case CENTER:
+ lines.addAll(jexer.bits.StringJustifier.center(p,
+ getWidth() - 1));
+ break;
+ case RIGHT:
+ lines.addAll(jexer.bits.StringJustifier.right(p,
+ getWidth() - 1));
+ break;
+ case FULL:
+ lines.addAll(jexer.bits.StringJustifier.full(p,
+ getWidth() - 1));
+ break;
}
+
for (int i = 0; i < lineSpacing; i++) {
lines.add("");
}
--- /dev/null
+/*
+ * Jexer - Java Text User Interface
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2017 Kevin Lamonte
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * @author Kevin Lamonte [kevin.lamonte@gmail.com]
+ * @version 1
+ */
+package jexer.bits;
+
+import java.util.List;
+import java.util.LinkedList;
+
+/**
+ * StringJustifier contains methods to convert one or more long lines of
+ * strings into justified text paragraphs.
+ */
+public final class StringJustifier {
+
+ /**
+ * Left-justify a string into a list of lines.
+ *
+ * @param str the string
+ * @param n the maximum number of characters in a line
+ * @return the list of lines
+ */
+ public static List<String> left(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * General procedure:
+ *
+ * 1. Split on '\n' into paragraphs.
+ *
+ * 2. Scan each line, noting the position of the last
+ * beginning-of-a-word.
+ *
+ * 3. Chop at the last #2 if the next beginning-of-a-word exceeds
+ * n.
+ *
+ * 4. Return the lines.
+ */
+
+ String [] rawLines = str.split("\n");
+ for (int i = 0; i < rawLines.length; i++) {
+ StringBuilder line = new StringBuilder();
+ StringBuilder word = new StringBuilder();
+ boolean inWord = false;
+ for (int j = 0; j < rawLines[i].length(); j++) {
+ char ch = rawLines[i].charAt(j);
+ if ((ch == ' ') || (ch == '\t')) {
+ if (inWord == true) {
+ // We have just transitioned from a word to
+ // whitespace. See if we have enough space to add
+ // the word to the line.
+ if (word.length() + line.length() > n) {
+ // This word will exceed the line length. Wrap
+ // at it instead.
+ result.add(line.toString());
+ line = new StringBuilder();
+ }
+ if ((word.toString().startsWith(" "))
+ && (line.length() == 0)
+ ) {
+ line.append(word.substring(1));
+ } else {
+ line.append(word);
+ }
+ word = new StringBuilder();
+ word.append(ch);
+ inWord = false;
+ } else {
+ // We are in the whitespace before another word. Do
+ // nothing.
+ }
+ } else {
+ if (inWord == true) {
+ // We are appending to a word.
+ word.append(ch);
+ } else {
+ // We have transitioned from whitespace to a word.
+ word.append(ch);
+ inWord = true;
+ }
+ }
+ } // for (int j = 0; j < rawLines[i].length(); j++)
+
+ if (word.length() + line.length() > n) {
+ // This word will exceed the line length. Wrap at it
+ // instead.
+ result.add(line.toString());
+ line = new StringBuilder();
+ }
+ if ((word.toString().startsWith(" "))
+ && (line.length() == 0)
+ ) {
+ line.append(word.substring(1));
+ } else {
+ line.append(word);
+ }
+ result.add(line.toString());
+ } // for (int i = 0; i < rawLines.length; i++) {
+
+ return result;
+ }
+
+ /**
+ * Right-justify a string into a list of lines.
+ *
+ * @param str the string
+ * @param n the maximum number of characters in a line
+ * @return the list of lines
+ */
+ public static List<String> right(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * Same as left(), but preceed each line with spaces to make it n
+ * chars long.
+ */
+ List<String> lines = left(str, n);
+ for (String line: lines) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < n - line.length(); i++) {
+ sb.append(' ');
+ }
+ sb.append(line);
+ result.add(sb.toString());
+ }
+
+ return result;
+ }
+
+ /**
+ * Center a string into a list of lines.
+ *
+ * @param str the string
+ * @param n the maximum number of characters in a line
+ * @return the list of lines
+ */
+ public static List<String> center(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * Same as left(), but preceed/succeed each line with spaces to make
+ * it n chars long.
+ */
+ List<String> lines = left(str, n);
+ for (String line: lines) {
+ StringBuilder sb = new StringBuilder();
+ int l = (n - line.length()) / 2;
+ int r = n - line.length() - l;
+ for (int i = 0; i < l; i++) {
+ sb.append(' ');
+ }
+ sb.append(line);
+ for (int i = 0; i < r; i++) {
+ sb.append(' ');
+ }
+ result.add(sb.toString());
+ }
+
+ return result;
+ }
+
+ /**
+ * Fully-justify a string into a list of lines.
+ *
+ * @param str the string
+ * @param n the maximum number of characters in a line
+ * @return the list of lines
+ */
+ public static List<String> full(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * Same as left(), but insert spaces between words to make each line
+ * n chars long. The "algorithm" here is pretty dumb: it performs a
+ * split on space and then re-inserts multiples of n between words.
+ */
+ List<String> lines = left(str, n);
+ for (int lineI = 0; lineI < lines.size() - 1; lineI++) {
+ String line = lines.get(lineI);
+ String [] words = line.split(" ");
+ if (words.length > 1) {
+ int charCount = 0;
+ for (int i = 0; i < words.length; i++) {
+ charCount += words[i].length();
+ }
+ int spaceCount = n - charCount;
+ int q = spaceCount / (words.length - 1);
+ int r = spaceCount % (words.length - 1);
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < words.length - 1; i++) {
+ sb.append(words[i]);
+ for (int j = 0; j < q; j++) {
+ sb.append(' ');
+ }
+ if (r > 0) {
+ sb.append(' ');
+ r--;
+ }
+ }
+ for (int j = 0; j < r; j++) {
+ sb.append(' ');
+ }
+ sb.append(words[words.length - 1]);
+ result.add(sb.toString());
+ } else {
+ result.add(line);
+ }
+ }
+ if (lines.size() > 0) {
+ result.add(lines.get(lines.size() - 1));
+ }
+
+ return result;
+ }
+
+}
public DemoTextWindow(final TApplication parent, final String title,
final String text) {
- super(parent, title, 0, 0, 44, 20, RESIZABLE);
- textField = addText(text, 1, 1, 40, 16);
+ super(parent, title, 0, 0, 44, 22, RESIZABLE);
+ textField = addText(text, 1, 3, 40, 16);
+
+ addButton("&Left", 1, 1, new TAction() {
+ public void DO() {
+ textField.leftJustify();
+ }
+ });
+
+ addButton("&Center", 10, 1, new TAction() {
+ public void DO() {
+ textField.centerJustify();
+ }
+ });
+
+ addButton("&Right", 21, 1, new TAction() {
+ public void DO() {
+ textField.rightJustify();
+ }
+ });
+
+ addButton("&Full", 31, 1, new TAction() {
+ public void DO() {
+ textField.fullJustify();
+ }
+ });
statusBar = newStatusBar("Reflowable text window");
statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
"\n" +
"Notice that some menu items should be disabled when this window has focus.\n" +
"\n" +
-"This library implements a text-based windowing system loosely\n" +
-"reminiscient of Borland's [Turbo\n" +
-"Vision](http://en.wikipedia.org/wiki/Turbo_Vision) library. For those\n" +
-"wishing to use the actual C++ Turbo Vision library, see [Sergio\n" +
-"Sigala's updated version](http://tvision.sourceforge.net/) that runs\n" +
+"This library implements a text-based windowing system loosely " +
+"reminiscient of Borland's [Turbo " +
+"Vision](http://en.wikipedia.org/wiki/Turbo_Vision) library. For those " +
+"wishing to use the actual C++ Turbo Vision library, see [Sergio " +
+"Sigala's updated version](http://tvision.sourceforge.net/) that runs " +
"on many more platforms.\n" +
"\n" +
-"This library is licensed MIT. See the file LICENSE for the full license\n" +
+"This library is licensed MIT. See the file LICENSE for the full license " +
"for the details.\n");
}
if (event.getType() == TResizeEvent.Type.WIDGET) {
// Resize the text field
textField.setWidth(event.getWidth() - 4);
- textField.setHeight(event.getHeight() - 4);
+ textField.setHeight(event.getHeight() - 6);
textField.reflow();
return;
}
git://git.nikiroo.be / fanfix.git / commitdiff