Ticket #2422: text_justification.patch

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/mvc/TextModelLogic.java

@@ -107 +107 @@
                                 if (clickCount % 3 == 2) {
                                         Break wordBreak = Breaks.WORD_BREAK;
                                         int endPos =  wordBreak.getNextBreakPos(rawText, pos);
-                                        while (endPos < rawText.getEnd() 
+                                        while (endPos <= rawText.getEnd() 
                                                         && endPos > rawText.getBegin()
                                                         && CommonChar.getWordSeparators().
                                                         contains(rawText.unitAt(endPos - 1).getChar())) {
@@ -745 +745 @@
                 case LINE_END :
                         lineEnds = layout.getLineEnds(caret);
                         if (lineEnds != null) {
-                                result = ImmTextUtils.advance(text, textBegin, lineEnds.getEnd());
+                                int end = lineEnds.getEnd();
+                                while (end > text.getBegin() && end < text.getEnd() && text.unitAt(end).getChar() == CommonChar.PARA_BREAK) {
+                                        end = ImmTextUtils.advance(text, end, -1);
+                                }
+                                        
+                                result = ImmTextUtils.advance(text, textBegin, end);
                         }
                         break;
 

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/model/TextUtils.java

@@ -26 +26 @@
          */
         public static int findPrevChar(ImmText text, int startPos, List<Character> chars) {
                 int pos = (startPos != -1) ? startPos : text.getBegin();
+                if (pos != text.getBegin() && pos == text.getEnd()) {
+                        --pos;
+                }
 
                 while (pos > text.getBegin()) {
                         if (chars.contains(text.unitAt(pos).getChar())) {
@@ -56 +59 @@
          */
         public static int findNextChar(ImmText text, int startIndex, List<Character> chars) {
 
-                assert startIndex >= 0 && startIndex < text.getEnd() : startIndex;
+                assert startIndex >= 0 && startIndex <= text.getEnd() : startIndex;
+                if (startIndex == text.getEnd ())
+                        return startIndex;
                 int index = startIndex + 1;
                 
                 while (index < text.getEnd()) {

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/layout/LayoutUtils.java

@@ -58 +58 @@
 
                         List<Character> lineBreaks = CommonChar.getEffectiveBreaks(CommonChar.LINE_BREAK);
                         int pos = TextUtils.findNextChar(this.areaText, begin, lineBreaks);
-
+                        
                         if (pos == -1 || this.areaText.getEnd() == 0) { 
                                 return null;
                         }
@@ -70 +70 @@
                                         pos = nextPos;
                                 }
                         }
+                        
+                        //checks for trailing para break and adds it (if any)
+                        int paraBreak = nextPos;
+                        if (paraBreak < this.areaText.getEnd() && 
+                                        this.areaText.unitAt(paraBreak).getChar() == CommonChar.PARA_BREAK )
+                                ++paraBreak;
 
                         assert ImmTextUtils.isIndexInText(pos, this.areaText);
                         ImmText res = 
                                 this.areaText.subText(new ImmTextInterval(begin, 
-                                                Math.min(nextPos, this.areaText.getEnd())));
+                                                Math.min(paraBreak, this.areaText.getEnd())));
                         this.areaText = 
-                                this.areaText.subText(new ImmTextInterval(pos, end));
+                                this.areaText.subText(new ImmTextInterval(paraBreak, end));
 
                         // Empty texts should not be returned.
                         if (res.getEnd() == 0) {

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/layout/LineBreakUtil.java

@@ -5 +5 @@
 
 import org.sophie2.base.model.text.elements.Break;
 import org.sophie2.base.model.text.elements.Breaks;
+import org.sophie2.base.model.text.elements.CommonChar;
 import org.sophie2.base.model.text.model.ImmText;
 import org.sophie2.base.model.text.model.TextRun;
 
@@ -124 +125 @@
                  *                      The text to take a word from.
                  * @param startIndex
                  *                      The index from which to search the word end.
+                 * @param whitespaceBreaks 
+                 *                      An list of indices containing all the positions of characters who come after consecutive whitespaces
                  * @return
                  *                      A {@link Word} with starting index - startIndex and ending index - the first 
                  *                      non-word-breaking character index after the first sequence of white spaces.
                  */
-                static Word get(ImmText text, int startIndex) {
+                static Word get(ImmText text, int startIndex, List<Integer> whitespaceBreaks) {
 
                         int requiredEnd = getWordEnd(text, startIndex);
 
@@ -138 +141 @@
 
                         assert requiredEnd <= text.getEnd();
 
+                        if (whitespaceBreaks != null) {
+                                /*
+                                 * Construct the list of whitespace positions. The actual values in the list are the first characters *after*
+                                 * whitespaces. Also if the word has trailing whitespaces, the position after the word's end is inserted in the list.
+                                 */
+                                int ind = start;
+                                while (ind < requiredEnd) {
+                                        char c = text.unitAt(ind).getChar();
+                                        if (c == CommonChar.SPACE || c == CommonChar.TAB) {
+                                                
+                                                while (ind < requiredEnd && 
+                                                                ((c = text.unitAt(ind).getChar()) == CommonChar.SPACE ||
+                                                                c == CommonChar.TAB ||
+                                                                c == CommonChar.LINE_BREAK)) {
+                                                        ++ind;
+                                                }
+                                                        
+                                                whitespaceBreaks.add(ind);
+                                        }
+                                        else
+                                                ++ind;
+                                }
+                                
+                                /*
+                                 * Construct each run between whitespace positions, starting from start
+                                 */
+                                for (int position : whitespaceBreaks) {
+                                        while (start < position 
+                                                        && (run = TextRun.create(text, start, position)) != null) {
+                                                runs.add (run);
+                                                start += run.getRunLength();
+                                        }
+                                        start = position;
+                                }
+                        }
+                        
+                        //Construct the final run (from the last whitespace position till the end of the word)
                         while (start < requiredEnd 
                                         && (run = TextRun.create(text, start, requiredEnd)) != null) {
                                 runs.add(run);

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/layout/HotAreaLayout.java

@@ -143 +143 @@
                                 List<HorizontalInterval> intervals = 
                                         LayoutUtils.splitToIntervals(newArea, baseY, lineHeight);
                                 
+                                char lastChar = textLine.unitAt(textLine.getEnd() - 1).getChar();
+                                boolean newPara = lastChar == CommonChar.PARA_BREAK,
+                                                endOfText = lastChar == CommonChar.DOC_BREAK;
+                                
                                 HotLineLayout newLineLayout = 
-                                        HotLineLayout.create(textLine, intervals, lineHeight, baseY, baselineOffset);
-                                lineList.add(newLineLayout);
+                                        HotLineLayout.create(textLine, intervals, lineHeight, baseY, baselineOffset, newPara || endOfText);
+                                
                                 int lineLength = newLineLayout.getConsumedLength();
                                 consumedLength += lineLength;
+                                
+                                /*
+                                 * We don't know whether the text line will be fully consumed in the created line layout
+                                 * So after we've created it, we check whether it is consumed, and if it's not and it has a para/doc break,
+                                 * we recreate the layout
+                                 */
+                                if ((newPara || endOfText) && lineLength < textLine.getEnd())
+                                        newLineLayout = HotLineLayout.create(textLine, intervals, lineHeight, baseY, baselineOffset, false);
+                                
+                                lineList.add(newLineLayout);
 
                                 baseY += lineHeight;
 
@@ -157 +171 @@
                                         break;
                                 }
 
-                                boolean newPara = 
-                                        (textLine.unitAt(textLine.getEnd() - 1).getChar() == CommonChar.PARA_BREAK);
                                 
+                                
+                                
                                 textLine = TextUtils.getSuffix(textLine, lineLength);
                                 if (textLine.getEnd() == 0 && newPara) {
                                         baseY += belowIndent;

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/elements/Breaks.java

@@ -36 +36 @@
                                 }
                                 tmpPos += advanceStep;
                         }
-                        return position;
+                        return tmpPos;
                 }
         };
 

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/layout/HotSegmentLayout.java

@@ -9 +9 @@
 import java.awt.geom.Line2D;
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 import org.sophie2.base.commons.util.position.ImmPoint;
 import org.sophie2.base.model.text.elements.CommonAttr;
@@ -33 +35 @@
          * Layout with no text. Used to fill spaces that should stay empty.
          */
         static final HotSegmentLayout EMPTY = 
-                new HotSegmentLayout(new ArrayList<TextRun>(), new ArrayList<DoublePoint>(), 0);
+                new HotSegmentLayout(new ArrayList<TextRun>(), new ArrayList<DoublePoint>(), new Integer[1], 0, 0);
 
         private final ArrayList<TextRun> textRuns;
         private final ArrayList<DoublePoint> locations;
+        private final Integer[] wordPos;
         private final double xOffset;
+        private final double textWidth;
 
         private HotSegmentLayout(
-                        ArrayList<TextRun> runs, ArrayList<DoublePoint> locations, double xOffset) {
+                        ArrayList<TextRun> runs, ArrayList<DoublePoint> locations, Integer[] wordPos, double xOffset, double textWidth) {
                 
                 this.textRuns = runs;
                 this.locations = locations;
                 this.xOffset = xOffset;
+                this.textWidth = textWidth;
+                this.wordPos = wordPos;
         }
 
         /**
@@ -58 +64 @@
          *                      The {@link HorizontalInterval} available for this segment.
          * @param baselineOffset
          *                      The baseline Y position of the text.
+         * @param lastInParagraph 
+         *                      Shows whether this segment is part of the last line of a paragraph.
          * @return
          *                      The created layout.
          */
         public static HotSegmentLayout create(
-                        int startPos, ImmText text, HorizontalInterval interval, float baselineOffset) {
+                        int startPos, ImmText text, HorizontalInterval interval, float baselineOffset, boolean lastInParagraph) {
 
                 final double totalWidth = interval.getWidth();
                 double remainingWidth = totalWidth;
                 ArrayList<TextRun> runs = new ArrayList<TextRun>();
                 ArrayList<DoublePoint> locations = new ArrayList<DoublePoint>();
+                
+                //contains the start indices of whitespace-delimited words (except the first one) 
+                ArrayList<Integer> wordPos = new ArrayList<Integer> ();
 
                 int position = startPos;
-                Word word;
+                Word word = null;
 
                 // Add as many words as possible.
+                ArrayList<Integer> curWordPos = new ArrayList<Integer> ();
                 while (position < text.getEnd() && 
-                                (word = Word.get(text, position)) != null &&
+                                (word = Word.get(text, position, curWordPos)) != null &&
                                 word.willFit(totalWidth, remainingWidth) && remainingWidth > 0) {
 
                         for (TextRun run : word.getRuns()) {
@@ -98 +110 @@
                         }
 
                         position += word.getSize();
+                        wordPos.addAll(curWordPos);
+                        curWordPos.clear();
                 }
-
+                
+                /*
+                 * Position contains the first position of a word we were unable to add - either the end of the text (i.e. we added everything), or
+                 * some index before it. If we have it in wordPos (i.e. it was the first positions after whitespaces), we have to remove it.
+                 */
+                if (!wordPos.isEmpty () && wordPos.get(wordPos.size() - 1) == position) {
+                        wordPos.remove(wordPos.size() - 1);
+                }
+        
                 // If no words are added, add as many chars as possible.
                 if (runs.size() == 0) {
                         SophieLog.debug("Could not layout a single word! Will split it to chars!");
@@ -113 +135 @@
                                 TextRun run = character.getRun();
 
                                 remainingWidth = addRun(run, baselineOffset, 
-                                                totalWidth, remainingWidth, runs, locations);
+                                                                        totalWidth, remainingWidth, runs, locations);
 
                                 if (remainingWidth == 0) {
                                         break;
@@ -143 +165 @@
 
                 TextAlign align = runs.get(0).getAttrValue(CommonAttr.PARA_ALIGNMENT);
 
+                Integer[] arr = new Integer[wordPos.size()];
+                for (int i = 0; i < wordPos.size(); ++i)
+                        arr[i] = wordPos.get(i) - startPos;
+                
                 HotSegmentLayout result = 
-                        new HotSegmentLayout(runs, locations, getAlignOffset(align, remainingWidth));
+                        new HotSegmentLayout(runs, locations, arr, getAlignOffset(align, remainingWidth), totalWidth - remainingWidth);
 
-                if (TextAlign.JUSTIFIED.equals(align)) {
+                if (TextAlign.JUSTIFIED.equals(align) && !lastInParagraph) {
                         return result.getJustifiedLayout(totalWidth);
                 }
 
@@ -391 +417 @@
         }
 
         private HotSegmentLayout getJustifiedLayout(double totalWidth) {
-                // TODO don't know how to do this.. --kyli
-                return this;
+                HotSegmentLayout result;
+                
+                /*
+                 * Calculate new locations for the runs, based on how much space 
+                 * we have remaining
+                 */             
+                
+                ArrayList<DoublePoint> newLocations = new ArrayList<DoublePoint> (this.locations.size());
+                int pos = 0, placed = 0;
+                
+                double remWidth = totalWidth - this.textWidth, averageW = (this.wordPos.length == 0 ? 0 : remWidth / (this.wordPos.length));
+                //do stuff with locations
+                for (int i = 0; i < this.textRuns.size(); ++i) {
+                        
+                        boolean found = (pos != 0 && Arrays.binarySearch (this.wordPos, pos) >= 0);
+                        placed += (found ? 1 : 0);
+                                        
+                        DoublePoint element = this.locations.get(i);
+                        DoublePoint newElem = new DoublePoint (element.getX() + placed*averageW, element.getY());
+                        newLocations.add(newElem);                              
+                        
+                        pos += this.textRuns.get(i).getRunLength();
+                }
+                result = new HotSegmentLayout (this.textRuns, newLocations, this.wordPos, this.xOffset, this.textWidth);
+                
+                return result;
         }
 }

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/layout/HotLineLayout.java

@@ -60 +60 @@
          *                      The Y position of the line, related to its parent area.
          * @param baselineOffset
          *                      The position of the text baseline - it will be aligned to it. 
+         * @param lastLineInPara 
+         *                      A value determining whether the lineText we're constructing from is last in its paragraph.
          * @return
          *                      The new {@link HotAreaLayout}.
          */
         public static HotLineLayout create(ImmText lineText, List<HorizontalInterval> intervals, 
-                        float lineHeight, float baseY, float baselineOffset) {
+                        float lineHeight, float baseY, float baselineOffset, boolean lastLineInPara) {
 
                 List<HotSegmentLayout> segmentList = new ArrayList<HotSegmentLayout>();
                 ImmText text = lineText;
@@ -74 +76 @@
                 for (HorizontalInterval interval : intervals) {
 
                         HotSegmentLayout newSegmentLayout = 
-                                HotSegmentLayout.create(position, text, interval, baselineOffset);
+                                HotSegmentLayout.create(position, text, interval, baselineOffset, lastLineInPara);
 
                         segmentList.add(newSegmentLayout);