Merged gcj-eclipse branch to trunk.

From-SVN: r120621

1 files changed, 95 insertions, 94 deletions

diff --git a/libjava/classpath/javax/swing/text/Utilities.java b/libjava/classpath/javax/swing/text/Utilities.java
index 36361f49796..d49d806cfa3 100644
--- a/libjava/classpath/javax/swing/text/Utilities.java
+++ b/libjava/classpath/javax/swing/text/Utilities.java
@@ -43,7 +43,6 @@ import java.awt.Graphics;
 import java.awt.Point;
 import java.text.BreakIterator;
 
-import javax.swing.SwingConstants;
 import javax.swing.text.Position.Bias;
 
 /**
@@ -55,10 +54,6 @@ import javax.swing.text.Position.Bias;
  */
 public class Utilities
 {
-  /**
-   * The length of the char buffer that holds the characters to be drawn.
-   */
-  private static final int BUF_LENGTH = 64;
 
   /**
    * Creates a new <code>Utilities</code> object.
@@ -94,13 +89,12 @@ public class Utilities
 
     // The font metrics of the current selected font.
     FontMetrics metrics = g.getFontMetrics();
+
     int ascent = metrics.getAscent();
 
     // The current x and y pixel coordinates.
     int pixelX = x;
-    int pixelY = y - ascent;
 
-    int pixelWidth = 0;
     int pos = s.offset;
     int len = 0;
     
@@ -109,44 +103,43 @@ public class Utilities
     for (int offset = s.offset; offset < end; ++offset)
       {
         char c = buffer[offset];
-        if (c == '\t' || c == '\n')
+        switch (c)
           {
+          case '\t':
             if (len > 0) {
-              g.drawChars(buffer, pos, len, pixelX, pixelY + ascent);            
-              pixelX += pixelWidth;
-              pixelWidth = 0;
+              g.drawChars(buffer, pos, len, pixelX, y);
+              pixelX += metrics.charsWidth(buffer, pos, len);
+              len = 0;
             }
             pos = offset+1;
-            len = 0;
+            if (e != null)
+              pixelX = (int) e.nextTabStop((float) pixelX, startOffset + offset
+                                           - s.offset);
+            else
+              pixelX += metrics.charWidth(' ');
+            x = pixelX;
+            break;
+          case '\n':
+          case '\r':
+            if (len > 0) {
+              g.drawChars(buffer, pos, len, pixelX, y);
+              pixelX += metrics.charsWidth(buffer, pos, len);
+              len = 0;
+            }
+            x = pixelX;
+            break;
+          default:
+            len += 1;
           }
-        
-	switch (c)
-	  {
-	  case '\t':
-	    // In case we have a tab, we just 'jump' over the tab.
-	    // When we have no tab expander we just use the width of ' '.
-	    if (e != null)
-	      pixelX = (int) e.nextTabStop((float) pixelX,
-					   startOffset + offset - s.offset);
-	    else
-	      pixelX += metrics.charWidth(' ');
-	    break;
-	  case '\n':
-	    // In case we have a newline, we must jump to the next line.
-	    pixelY += metrics.getHeight();
-	    pixelX = x;
-	    break;
-	  default:
-            ++len;
-	    pixelWidth += metrics.charWidth(buffer[offset]);
-	    break;
-	  }
       }
 
     if (len > 0)
-      g.drawChars(buffer, pos, len, pixelX, pixelY + ascent);            
+      {
+        g.drawChars(buffer, pos, len, pixelX, y);
+        pixelX += metrics.charsWidth(buffer, pos, len);
+      }
     
-    return pixelX + pixelWidth;
+    return pixelX;
   }
 
   /**
@@ -174,7 +167,9 @@ public class Utilities
     // The current maximum width.
     int maxWidth = 0;
 
-    for (int offset = s.offset; offset < (s.offset + s.count); ++offset)
+    int end = s.offset + s.count;
+    int count = 0;
+    for (int offset = s.offset; offset < end; offset++)
       {
 	switch (buffer[offset])
 	  {
@@ -182,7 +177,7 @@ public class Utilities
 	    // In case we have a tab, we just 'jump' over the tab.
 	    // When we have no tab expander we just use the width of 'm'.
 	    if (e != null)
-	      pixelX = (int) e.nextTabStop((float) pixelX,
+	      pixelX = (int) e.nextTabStop(pixelX,
 					   startOffset + offset - s.offset);
 	    else
 	      pixelX += metrics.charWidth(' ');
@@ -190,21 +185,18 @@ public class Utilities
 	  case '\n':
 	    // In case we have a newline, we must 'draw'
 	    // the buffer and jump on the next line.
-	    pixelX += metrics.charWidth(buffer[offset]);
-	    maxWidth = Math.max(maxWidth, pixelX - x);
-	    pixelX = x;
-	    break;
-	  default:
-	    // Here we draw the char.
-	    pixelX += metrics.charWidth(buffer[offset]);
-	    break;
-	  }
+	    pixelX += metrics.charsWidth(buffer, offset - count, count);
+            count = 0;
+            break;
+          default:
+            count++;
+          }
       }
 
     // Take the last line into account.
-    maxWidth = Math.max(maxWidth, pixelX - x);
+    pixelX += metrics.charsWidth(buffer, end - count, count);
 
-    return maxWidth;
+    return pixelX - x;
   }
 
   /**
@@ -239,43 +231,41 @@ public class Utilities
                                               int x, TabExpander te, int p0,
                                               boolean round)
   {
-    // At the end of the for loop, this holds the requested model location
-    int pos;
+    int found = s.count;
     int currentX = x0;
-    int width = 0;
+    int nextX = currentX;
     
-    for (pos = 0; pos < s.count; pos++)
+    int end = s.offset + s.count;
+    for (int pos = s.offset; pos < end && found == s.count; pos++)
       {
-        char nextChar = s.array[s.offset+pos];
-        
-        if (nextChar == 0)
-            break;
+        char nextChar = s.array[pos];
         
         if (nextChar != '\t')
-          width = fm.charWidth(nextChar);
+          nextX += fm.charWidth(nextChar);
         else
           {
             if (te == null)
-              width = fm.charWidth(' ');
+              nextX += fm.charWidth(' ');
             else
-              width = ((int) te.nextTabStop(currentX, pos)) - currentX;
+              nextX += ((int) te.nextTabStop(nextX, p0 + pos - s.offset));
           }
         
-        if (round)
+        if (x >= currentX && x < nextX)
           {
-            if (currentX + (width>>1) > x)
-              break;
-          }
-        else
-          {
-            if (currentX + width > x)
-              break;
+            // Found position.
+            if ((! round) || ((x - currentX) < (nextX - x)))
+              {
+                found = pos - s.offset;
+              }
+            else
+              {
+                found = pos + 1 - s.offset;
+              }
           }
-        
-        currentX += width;
+        currentX = nextX;
       }
 
-    return pos + p0;
+    return found;
   }
 
   /**
@@ -543,28 +533,39 @@ public class Utilities
                                            int x0, int x, TabExpander e,
                                            int startOffset)
   {
-    int mark = Utilities.getTabbedTextOffset(s, metrics, x0, x, e, startOffset, false);
-    BreakIterator breaker = BreakIterator.getWordInstance();
-    breaker.setText(s);
-
-    // If startOffset and s.offset differ then we need to use
-    // that difference two convert the offset between the two metrics. 
-    int shift = startOffset - s.offset;
-    
+    int mark = Utilities.getTabbedTextOffset(s, metrics, x0, x, e, startOffset,
+                                             false);
+    int breakLoc = mark;
     // If mark is equal to the end of the string, just use that position.
-    if (mark >= shift + s.count)
-      return mark;
-    
-    // Try to find a word boundary previous to the mark at which we 
-    // can break the text.
-    int preceding = breaker.preceding(mark + 1 - shift);
-    
-    if (preceding != 0)
-      return preceding + shift;
-    
-    // If preceding is 0 we couldn't find a suitable word-boundary so
-    // just break it on the character boundary
-    return mark;
+    if (mark < s.count - 1)
+      {
+        for (int i = s.offset + mark; i >= s.offset; i--)
+          {
+            char ch = s.array[i];
+            if (ch < 256)
+              {
+                // For ASCII simply scan backwards for whitespace.
+                if (Character.isWhitespace(ch))
+                  {
+                    breakLoc = i - s.offset + 1;
+                    break;
+                  }
+              }
+            else
+              {
+                // Only query BreakIterator for complex chars.
+                BreakIterator bi = BreakIterator.getLineInstance();
+                bi.setText(s);
+                int pos = bi.preceding(i + 1);
+                if (pos > s.offset)
+                  {
+                    breakLoc = breakLoc - s.offset;
+                  }
+                break;
+              }
+          }
+      }
+    return breakLoc;
   }
 
   /**
@@ -712,12 +713,12 @@ public class Utilities
                                          offset,
                                          Bias.Forward,
                                          direction,
-                                         null)
+                                         new Position.Bias[1])
           : t.getUI().getNextVisualPositionFrom(t,
                                                 offset,
                                                 Bias.Forward,
                                                 direction,
-                                                null);
+                                                new Position.Bias[1]);
       }
     catch (BadLocationException ble)
     {