From: Kevin Lamonte <kevin.lamonte@gmail.com>
Date: Sat, 8 Jul 2017 19:57:56 +0000 (-0400)
Subject: #10 left/center/right/full justified text for TText
X-Git-Url: https://git.nikiroo.be/?a=commitdiff_plain;h=7657ad8c9c48bdde0c7d693859e942bd2186b1f7;p=nikiroo-utils.git

#10 left/center/right/full justified text for TText
---

diff --git a/docs/TODO.md b/docs/TODO.md
index 0ab6e91..eb7164f 100644
--- a/docs/TODO.md
+++ b/docs/TODO.md
@@ -18,7 +18,6 @@ BUG: TTreeView.reflow() doesn't keep the vertical dot within the
     - Expose toTop()/toLeft()/...
 
 - TText:
-  - Justification (left, right, center, proportional) (#10)
   - Scrollbars adjust automatically
     - Expose toTop()/toLeft()/...
 
diff --git a/src/jexer/TText.java b/src/jexer/TText.java
index 66fa44b..21c2f1f 100644
--- a/src/jexer/TText.java
+++ b/src/jexer/TText.java
@@ -50,6 +50,36 @@ import jexer.event.TMouseEvent;
  */
 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.
      */
@@ -129,46 +159,45 @@ public final class TText extends TWidget {
     }
 
     /**
-     * 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();
     }
 
     /**
@@ -181,10 +210,25 @@ public final class TText extends TWidget {
         // 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("");
             }
diff --git a/src/jexer/TWindow.java b/src/jexer/TWindow.java
index af8c229..afb0bc0 100644
--- a/src/jexer/TWindow.java
+++ b/src/jexer/TWindow.java
@@ -316,7 +316,7 @@ public class TWindow extends TWidget {
     }
 
     /**
-     * Restote (unmaximize) window.
+     * Restore (unmaximize) window.
      */
     private void restore() {
         setWidth(restoreWindowWidth);
diff --git a/src/jexer/bits/StringJustifier.java b/src/jexer/bits/StringJustifier.java
new file mode 100644
index 0000000..bbaa9cb
--- /dev/null
+++ b/src/jexer/bits/StringJustifier.java
@@ -0,0 +1,240 @@
+/*
+ * 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;
+    }
+
+}
diff --git a/src/jexer/demos/DemoTextWindow.java b/src/jexer/demos/DemoTextWindow.java
index 19b6502..1c51296 100644
--- a/src/jexer/demos/DemoTextWindow.java
+++ b/src/jexer/demos/DemoTextWindow.java
@@ -54,8 +54,32 @@ public class DemoTextWindow extends TWindow {
     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");
@@ -75,14 +99,14 @@ public class DemoTextWindow extends TWindow {
 "\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");
 
     }
@@ -97,7 +121,7 @@ public class DemoTextWindow extends TWindow {
         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;
         }