001/* GlyphView.java -- A view to render styled text
002   Copyright (C) 2005  Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package javax.swing.text;
040
041import gnu.classpath.SystemProperties;
042
043import java.awt.Color;
044import java.awt.Container;
045import java.awt.Font;
046import java.awt.FontMetrics;
047import java.awt.Graphics;
048import java.awt.Graphics2D;
049import java.awt.Rectangle;
050import java.awt.Shape;
051import java.awt.Toolkit;
052import java.awt.font.FontRenderContext;
053import java.awt.font.TextHitInfo;
054import java.awt.font.TextLayout;
055import java.awt.geom.Rectangle2D;
056
057import javax.swing.SwingConstants;
058import javax.swing.event.DocumentEvent;
059import javax.swing.text.Position.Bias;
060
061/**
062 * Renders a run of styled text. This {@link View} subclass paints the
063 * characters of the <code>Element</code> it is responsible for using
064 * the style information from that <code>Element</code>.
065 *
066 * @author Roman Kennke (roman@kennke.org)
067 */
068public class GlyphView extends View implements TabableView, Cloneable
069{
070
071  /**
072   * An abstract base implementation for a glyph painter for
073   * <code>GlyphView</code>.
074   */
075  public abstract static class GlyphPainter
076  {
077    /**
078     * Creates a new <code>GlyphPainer</code>.
079     */
080    public GlyphPainter()
081    {
082      // Nothing to do here.
083    }
084
085    /**
086     * Returns the ascent of the font that is used by this glyph painter.
087     *
088     * @param v the glyph view
089     *
090     * @return the ascent of the font that is used by this glyph painter
091     */
092    public abstract float getAscent(GlyphView v);
093
094    /**
095     * Returns the descent of the font that is used by this glyph painter.
096     *
097     * @param v the glyph view
098     *
099     * @return the descent of the font that is used by this glyph painter
100     */
101    public abstract float getDescent(GlyphView v);
102
103    /**
104     * Returns the full height of the rendered text.
105     *
106     * @return the full height of the rendered text
107     */
108    public abstract float getHeight(GlyphView view);
109
110    /**
111     * Determines the model offset, so that the text between <code>p0</code>
112     * and this offset fits within the span starting at <code>x</code> with
113     * the length of <code>len</code>. 
114     *
115     * @param v the glyph view
116     * @param p0 the starting offset in the model
117     * @param x the start location in the view
118     * @param len the length of the span in the view
119     */
120    public abstract int getBoundedPosition(GlyphView v, int p0, float x,
121                                           float len);
122
123    /**
124     * Paints the glyphs.
125     *
126     * @param view the glyph view to paint
127     * @param g the graphics context to use for painting
128     * @param a the allocation of the glyph view
129     * @param p0 the start position (in the model) from which to paint
130     * @param p1 the end position (in the model) to which to paint
131     */
132    public abstract void paint(GlyphView view, Graphics g, Shape a, int p0,
133                               int p1);
134
135    /**
136     * Maps a position in the document into the coordinate space of the View.
137     * The output rectangle usually reflects the font height but has a width
138     * of zero.
139     *
140     * @param view the glyph view
141     * @param pos the position of the character in the model
142     * @param a the area that is occupied by the view
143     * @param b either {@link Position.Bias#Forward} or
144     *        {@link Position.Bias#Backward} depending on the preferred
145     *        direction bias. If <code>null</code> this defaults to
146     *        <code>Position.Bias.Forward</code>
147     *
148     * @return a rectangle that gives the location of the document position
149     *         inside the view coordinate space
150     *
151     * @throws BadLocationException if <code>pos</code> is invalid
152     * @throws IllegalArgumentException if b is not one of the above listed
153     *         valid values
154     */
155    public abstract Shape modelToView(GlyphView view, int pos, Position.Bias b,
156                                      Shape a)
157      throws BadLocationException;
158
159    /**
160     * Maps a visual position into a document location.
161     *
162     * @param v the glyph view
163     * @param x the X coordinate of the visual position
164     * @param y the Y coordinate of the visual position
165     * @param a the allocated region
166     * @param biasRet filled with the bias of the model location on method exit
167     *
168     * @return the model location that represents the specified view location
169     */
170    public abstract int viewToModel(GlyphView v, float x, float y, Shape a,
171                                    Position.Bias[] biasRet);
172
173    /**
174     * Determine the span of the glyphs from location <code>p0</code> to
175     * location <code>p1</code>. If <code>te</code> is not <code>null</code>,
176     * then TABs are expanded using this <code>TabExpander</code>.
177     * The parameter <code>x</code> is the location at which the view is
178     * located (this is important when using TAB expansion).
179     *
180     * @param view the glyph view
181     * @param p0 the starting location in the document model
182     * @param p1 the end location in the document model
183     * @param te the tab expander to use
184     * @param x the location at which the view is located
185     *
186     * @return the span of the glyphs from location <code>p0</code> to
187     *         location <code>p1</code>, possibly using TAB expansion
188     */
189    public abstract float getSpan(GlyphView view, int p0, int p1,
190                                  TabExpander te, float x);
191
192
193    /**
194     * Returns the model location that should be used to place a caret when
195     * moving the caret through the document.
196     *
197     * @param v the glyph view
198     * @param pos the current model location
199     * @param b the bias for <code>p</code>
200     * @param a the allocated region for the glyph view
201     * @param direction the direction from the current position; Must be one of
202     *        {@link SwingConstants#EAST}, {@link SwingConstants#WEST},
203     *        {@link SwingConstants#NORTH} or {@link SwingConstants#SOUTH}
204     * @param biasRet filled with the bias of the resulting location when method
205     *        returns
206     *
207     * @return the location within the document that should be used to place the
208     *         caret when moving the caret around the document
209     *
210     * @throws BadLocationException if <code>pos</code> is an invalid model
211     *         location
212     * @throws IllegalArgumentException if <code>d</code> is invalid
213     */
214    public int getNextVisualPositionFrom(GlyphView v, int pos, Position.Bias b,
215                                         Shape a, int direction,
216                                         Position.Bias[] biasRet)
217      throws BadLocationException
218
219    {
220      int result = pos;
221      switch (direction)
222      {
223        case SwingConstants.EAST:
224          result = pos + 1;
225          break;
226        case SwingConstants.WEST:
227          result = pos - 1;
228          break;
229        case SwingConstants.NORTH:
230        case SwingConstants.SOUTH:
231        default:
232          // This should be handled in enclosing view, since the glyph view
233          // does not layout vertically.
234          break;
235      }
236      return result;
237    }
238
239    /**
240     * Returns a painter that can be used to render the specified glyph view.
241     * If this glyph painter is stateful, then it should return a new instance.
242     * However, if this painter is stateless it should return itself. The
243     * default behaviour is to return itself.
244     *
245     * @param v the glyph view for which to create a painter
246     * @param p0 the start offset of the rendered area
247     * @param p1 the end offset of the rendered area
248     *
249     * @return a painter that can be used to render the specified glyph view
250     */
251    public GlyphPainter getPainter(GlyphView v, int p0, int p1)
252    {
253      return this;
254    }
255  }
256
257  /**
258   * A GlyphPainter implementation based on TextLayout. This should give
259   * better performance in Java2D environments.
260   */
261  private static class J2DGlyphPainter
262    extends GlyphPainter
263  {
264
265    /**
266     * The text layout.
267     */
268    TextLayout textLayout;
269
270    /**
271     * Creates a new J2DGlyphPainter.
272     *
273     * @param str the string
274     * @param font the font
275     * @param frc the font render context
276     */
277    J2DGlyphPainter(String str, Font font, FontRenderContext frc)
278    {
279      textLayout = new TextLayout(str, font, frc);
280    }
281
282    /**
283     * Returns null so that GlyphView.checkPainter() creates a new instance.
284     */
285    public GlyphPainter getPainter(GlyphView v, int p0, int p1)
286    {
287      return null;
288    }
289
290    /**
291     * Delegates to the text layout.
292     */
293    public float getAscent(GlyphView v)
294    {
295      return textLayout.getAscent();
296    }
297
298    /**
299     * Delegates to the text layout.
300     */
301    public int getBoundedPosition(GlyphView v, int p0, float x, float len)
302    {
303      int pos;
304      TextHitInfo hit = textLayout.hitTestChar(len, 0);
305      if (hit.getCharIndex() == -1 && ! textLayout.isLeftToRight())
306        pos = v.getEndOffset();
307      else
308        {
309          pos = hit.isLeadingEdge() ? hit.getInsertionIndex()
310                                    : hit.getInsertionIndex() - 1;
311          pos += v.getStartOffset();
312        }
313      return pos;
314    }
315
316    /**
317     * Delegates to the text layout.
318     */
319    public float getDescent(GlyphView v)
320    {
321      return textLayout.getDescent();
322    }
323
324    /**
325     * Delegates to the text layout.
326     */
327    public float getHeight(GlyphView view)
328    {
329      return textLayout.getAscent() + textLayout.getDescent()
330             + textLayout.getLeading();
331    }
332
333    /**
334     * Delegates to the text layout.
335     */
336    public float getSpan(GlyphView v, int p0, int p1, TabExpander te, float x)
337    {
338      float span;
339      if (p0 == v.getStartOffset() && p1 == v.getEndOffset())
340        span = textLayout.getAdvance();
341      else
342        {
343          int start = v.getStartOffset();
344          int i0 = p0 - start;
345          int i1 = p1 - start;
346          TextHitInfo hit0 = TextHitInfo.afterOffset(i0);
347          TextHitInfo hit1 = TextHitInfo.afterOffset(i1);
348          float x0 = textLayout.getCaretInfo(hit0)[0];
349          float x1 = textLayout.getCaretInfo(hit1)[0];
350          span = Math.abs(x1 - x0);
351        }
352      return span;
353    }
354
355    /**
356     * Delegates to the text layout.
357     */
358    public Shape modelToView(GlyphView v, int pos, Bias b, Shape a)
359      throws BadLocationException
360    {
361      int offs = pos - v.getStartOffset();
362      // Create copy here to protect original shape.
363      Rectangle2D bounds = a.getBounds2D();
364      TextHitInfo hit =
365        b == Position.Bias.Forward ? TextHitInfo.afterOffset(offs)
366                                   : TextHitInfo.beforeOffset(offs);
367      float[] loc = textLayout.getCaretInfo(hit);
368      bounds.setRect(bounds.getX() + loc[0], bounds.getY(), 1,
369                     bounds.getHeight());
370      return bounds;
371    }
372
373    /**
374     * Delegates to the text layout.
375     */
376    public void paint(GlyphView view, Graphics g, Shape a, int p0, int p1)
377    {
378      // Can't paint this with plain graphics.
379      if (g instanceof Graphics2D)
380        {
381          Graphics2D g2d = (Graphics2D) g;
382          Rectangle2D b = a instanceof Rectangle2D ? (Rectangle2D) a
383                                                   : a.getBounds2D();
384          float x = (float) b.getX();
385          float y = (float) b.getY() + textLayout.getAscent()
386                    + textLayout.getLeading();
387          // TODO: Try if clipping makes things faster for narrow views.
388          textLayout.draw(g2d, x, y);
389        }
390    }
391
392    /**
393     * Delegates to the text layout.
394     */
395    public int viewToModel(GlyphView v, float x, float y, Shape a,
396                           Bias[] biasRet)
397    {
398      Rectangle2D bounds = a instanceof Rectangle2D ? (Rectangle2D) a
399                                                    : a.getBounds2D();
400      TextHitInfo hit = textLayout.hitTestChar(x - (float) bounds.getX(), 0);
401      int pos = hit.getInsertionIndex();
402      biasRet[0] = hit.isLeadingEdge() ? Position.Bias.Forward
403                                       : Position.Bias.Backward;
404      return pos + v.getStartOffset();
405    }
406    
407  }
408
409  /**
410   * The default <code>GlyphPainter</code> used in <code>GlyphView</code>.
411   */
412  static class DefaultGlyphPainter extends GlyphPainter
413  {
414    FontMetrics fontMetrics;
415
416    /**
417     * Returns the full height of the rendered text.
418     *
419     * @return the full height of the rendered text
420     */
421    public float getHeight(GlyphView view)
422    {
423      updateFontMetrics(view);
424      float height = fontMetrics.getHeight();
425      return height;
426    }
427    
428    /**
429     * Paints the glyphs.
430     *
431     * @param view the glyph view to paint
432     * @param g the graphics context to use for painting
433     * @param a the allocation of the glyph view
434     * @param p0 the start position (in the model) from which to paint
435     * @param p1 the end position (in the model) to which to paint
436     */
437    public void paint(GlyphView view, Graphics g, Shape a, int p0,
438                      int p1)
439    {
440      updateFontMetrics(view);
441      Rectangle r = a instanceof Rectangle ? (Rectangle) a : a.getBounds();
442      TabExpander tabEx = view.getTabExpander();
443      Segment txt = view.getText(p0, p1);
444
445      // Find out the X location at which we have to paint.
446      int x = r.x;
447      int p = view.getStartOffset();
448      if (p != p0)
449        {
450          int width = Utilities.getTabbedTextWidth(txt, fontMetrics,x, tabEx,
451                                                   p);
452          x += width;
453        }
454      // Find out Y location.
455      int y = r.y + fontMetrics.getHeight() - fontMetrics.getDescent();
456
457      // Render the thing.
458      g.setFont(fontMetrics.getFont());
459      Utilities.drawTabbedText(txt, x, y, g, tabEx, p0);
460
461    }
462
463    /**
464     * Maps a position in the document into the coordinate space of the View.
465     * The output rectangle usually reflects the font height but has a width
466     * of zero.
467     *
468     * @param view the glyph view
469     * @param pos the position of the character in the model
470     * @param a the area that is occupied by the view
471     * @param b either {@link Position.Bias#Forward} or
472     *        {@link Position.Bias#Backward} depending on the preferred
473     *        direction bias. If <code>null</code> this defaults to
474     *        <code>Position.Bias.Forward</code>
475     *
476     * @return a rectangle that gives the location of the document position
477     *         inside the view coordinate space
478     *
479     * @throws BadLocationException if <code>pos</code> is invalid
480     * @throws IllegalArgumentException if b is not one of the above listed
481     *         valid values
482     */
483    public Shape modelToView(GlyphView view, int pos, Position.Bias b,
484                             Shape a)
485      throws BadLocationException
486    {
487      updateFontMetrics(view);
488      Element el = view.getElement();
489      Segment txt = view.getText(el.getStartOffset(), pos);
490      Rectangle bounds = a instanceof Rectangle ? (Rectangle) a
491                                                : a.getBounds();
492      TabExpander expander = view.getTabExpander();
493      int width = Utilities.getTabbedTextWidth(txt, fontMetrics, bounds.x,
494                                               expander,
495                                               view.getStartOffset());
496      int height = fontMetrics.getHeight();
497      Rectangle result = new Rectangle(bounds.x + width, bounds.y,
498                                       0, height);
499      return result;
500    }
501
502    /**
503     * Determine the span of the glyphs from location <code>p0</code> to
504     * location <code>p1</code>. If <code>te</code> is not <code>null</code>,
505     * then TABs are expanded using this <code>TabExpander</code>.
506     * The parameter <code>x</code> is the location at which the view is
507     * located (this is important when using TAB expansion).
508     *
509     * @param view the glyph view
510     * @param p0 the starting location in the document model
511     * @param p1 the end location in the document model
512     * @param te the tab expander to use
513     * @param x the location at which the view is located
514     *
515     * @return the span of the glyphs from location <code>p0</code> to
516     *         location <code>p1</code>, possibly using TAB expansion
517     */
518    public float getSpan(GlyphView view, int p0, int p1,
519                         TabExpander te, float x)
520    {
521      updateFontMetrics(view);
522      Segment txt = view.getText(p0, p1);
523      int span = Utilities.getTabbedTextWidth(txt, fontMetrics, (int) x, te,
524                                              p0);
525      return span;
526    }
527
528    /**
529     * Returns the ascent of the text run that is rendered by this
530     * <code>GlyphPainter</code>.
531     *
532     * @param v the glyph view
533     *
534     * @return the ascent of the text run that is rendered by this
535     *         <code>GlyphPainter</code>
536     *
537     * @see FontMetrics#getAscent()
538     */
539    public float getAscent(GlyphView v)
540    {
541      updateFontMetrics(v);
542      return fontMetrics.getAscent();
543    }
544
545    /**
546     * Returns the descent of the text run that is rendered by this
547     * <code>GlyphPainter</code>.
548     *
549     * @param v the glyph view
550     *
551     * @return the descent of the text run that is rendered by this
552     *         <code>GlyphPainter</code>
553     *
554     * @see FontMetrics#getDescent()
555     */
556    public float getDescent(GlyphView v)
557    {
558      updateFontMetrics(v);
559      return fontMetrics.getDescent();
560    }
561
562    /**
563     * Determines the model offset, so that the text between <code>p0</code>
564     * and this offset fits within the span starting at <code>x</code> with
565     * the length of <code>len</code>. 
566     *
567     * @param v the glyph view
568     * @param p0 the starting offset in the model
569     * @param x the start location in the view
570     * @param len the length of the span in the view
571     */
572    public int getBoundedPosition(GlyphView v, int p0, float x, float len)
573    {
574      updateFontMetrics(v);
575      TabExpander te = v.getTabExpander();
576      Segment txt = v.getText(p0, v.getEndOffset());
577      int pos = Utilities.getTabbedTextOffset(txt, fontMetrics, (int) x,
578                                              (int) (x + len), te, p0, false);
579      return pos + p0;
580    }
581
582    /**
583     * Maps a visual position into a document location.
584     *
585     * @param v the glyph view
586     * @param x the X coordinate of the visual position
587     * @param y the Y coordinate of the visual position
588     * @param a the allocated region
589     * @param biasRet filled with the bias of the model location on method exit
590     *
591     * @return the model location that represents the specified view location
592     */
593    public int viewToModel(GlyphView v, float x, float y, Shape a,
594                           Bias[] biasRet)
595    {
596      Rectangle r = a instanceof Rectangle ? (Rectangle) a : a.getBounds();
597      int p0 = v.getStartOffset();
598      int p1 = v.getEndOffset();
599      TabExpander te = v.getTabExpander();
600      Segment s = v.getText(p0, p1);
601      int offset = Utilities.getTabbedTextOffset(s, fontMetrics, r.x, (int) x,
602                                                 te, p0);
603      int ret = p0 + offset;
604      if (ret == p1)
605        ret--;
606      biasRet[0] = Position.Bias.Forward;
607      return ret;
608    }
609
610    private void updateFontMetrics(GlyphView v)
611    {
612      Font font = v.getFont();
613      if (fontMetrics == null || ! font.equals(fontMetrics.getFont()))
614        {
615          Container c = v.getContainer();
616          FontMetrics fm;
617          if (c != null)
618            fm = c.getFontMetrics(font);
619          else
620            fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
621          fontMetrics = fm;
622        }
623    }
624  }
625
626  /**
627   * The GlyphPainer used for painting the glyphs.
628   */
629  GlyphPainter glyphPainter;
630
631  /**
632   * The start offset within the document for this view.
633   */
634  private int offset;
635
636  /**
637   * The end offset within the document for this view.
638   */
639  private int length;
640
641  /**
642   * The x location against which the tab expansion is done.
643   */
644  private float tabX;
645
646  /**
647   * The tab expander that is used in this view.
648   */
649  private TabExpander tabExpander;
650
651  /**
652   * Creates a new <code>GlyphView</code> for the given <code>Element</code>.
653   *
654   * @param element the element that is rendered by this GlyphView
655   */
656  public GlyphView(Element element)
657  {
658    super(element);
659    offset = 0;
660    length = 0;
661  }
662
663  /**
664   * Returns the <code>GlyphPainter</code> that is used by this
665   * <code>GlyphView</code>. If no <code>GlyphPainer</code> has been installed
666   * <code>null</code> is returned.
667   *
668   * @return the glyph painter that is used by this
669   *         glyph view or <code>null</code> if no glyph painter has been
670   *         installed
671   */
672  public GlyphPainter getGlyphPainter()
673  {
674    return glyphPainter;
675  }
676
677  /**
678   * Sets the {@link GlyphPainter} to be used for this <code>GlyphView</code>.
679   *
680   * @param painter the glyph painter to be used for this glyph view
681   */
682  public void setGlyphPainter(GlyphPainter painter)
683  {
684    glyphPainter = painter;
685  }
686
687  /**
688   * Checks if a <code>GlyphPainer</code> is installed. If this is not the
689   * case, a default painter is installed.
690   */
691  protected void checkPainter()
692  {
693    if (glyphPainter == null)
694      {
695        if ("true".equals(
696                 SystemProperties.getProperty("gnu.javax.swing.noGraphics2D")))
697          {
698            glyphPainter = new DefaultGlyphPainter();
699          }
700        else
701          {
702            Segment s = getText(getStartOffset(), getEndOffset());
703            glyphPainter = new J2DGlyphPainter(s.toString(), getFont(),
704                                               new FontRenderContext(null,
705                                                                     false,
706                                                                     false));
707          }
708      }
709  }
710
711  /**
712   * Renders the <code>Element</code> that is associated with this
713   * <code>View</code>.
714   *
715   * @param g the <code>Graphics</code> context to render to
716   * @param a the allocated region for the <code>Element</code>
717   */
718  public void paint(Graphics g, Shape a)
719  {
720    checkPainter();
721    int p0 = getStartOffset();
722    int p1 = getEndOffset();
723
724    Rectangle r = a instanceof Rectangle ? (Rectangle) a : a.getBounds();
725    Container c = getContainer();
726
727    Color fg = getForeground();
728    JTextComponent tc = null;
729    if (c instanceof JTextComponent)
730      {
731        tc = (JTextComponent) c;
732        if (! tc.isEnabled())
733          fg = tc.getDisabledTextColor();
734      }
735    Color bg = getBackground();
736    if (bg != null)
737      {
738        g.setColor(bg);
739        g.fillRect(r.x, r.y, r.width, r.height);
740      }
741
742    
743    // Paint layered highlights if there are any.
744    if (tc != null)
745      {
746        Highlighter h = tc.getHighlighter();
747        if (h instanceof LayeredHighlighter)
748          {
749            LayeredHighlighter lh = (LayeredHighlighter) h;
750            lh.paintLayeredHighlights(g, p0, p1, a, tc, this);
751          }
752      }
753
754    g.setColor(fg);
755    glyphPainter.paint(this, g, a, p0, p1);
756    boolean underline = isUnderline();
757    boolean striked = isStrikeThrough();
758    if (underline || striked)
759      {
760        View parent = getParent();
761        // X coordinate.
762        if (parent != null && parent.getEndOffset() == p1)
763          {
764            // Strip whitespace.
765            Segment s = getText(p0, p1);
766            while (s.count > 0 && Character.isWhitespace(s.array[s.count - 1]))
767              {
768                p1--;
769                s.count--;
770              }
771          }
772        int x0 = r.x;
773        int p = getStartOffset();
774        TabExpander tabEx = getTabExpander();
775        if (p != p0)
776          x0 += (int) glyphPainter.getSpan(this, p, p0, tabEx, x0);
777        int x1 = x0 + (int) glyphPainter.getSpan(this, p0, p1, tabEx, x0);
778        // Y coordinate.
779        int y = r.y + r.height - (int) glyphPainter.getDescent(this);
780        if (underline)
781          {
782            int yTmp = y;
783            yTmp += 1;
784            g.drawLine(x0, yTmp, x1, yTmp);
785          }
786        if (striked)
787          {
788            int yTmp = y;
789            yTmp -= (int) glyphPainter.getAscent(this);
790            g.drawLine(x0, yTmp, x1, yTmp);
791          }
792      }
793  }
794
795
796  /**
797   * Returns the preferred span of the content managed by this
798   * <code>View</code> along the specified <code>axis</code>.
799   *
800   * @param axis the axis
801   *
802   * @return the preferred span of this <code>View</code>.
803   */
804  public float getPreferredSpan(int axis)
805  {
806    float span = 0;
807    checkPainter();
808    GlyphPainter painter = getGlyphPainter();
809    switch (axis)
810      {
811      case X_AXIS:
812        TabExpander tabEx = null;
813        View parent = getParent();
814        if (parent instanceof TabExpander)
815          tabEx = (TabExpander) parent;
816        span = painter.getSpan(this, getStartOffset(), getEndOffset(),
817                               tabEx, 0.F);
818        break;
819      case Y_AXIS:
820        span = painter.getHeight(this);
821        if (isSuperscript())
822          span += span / 3;
823        break;
824      default:
825        throw new IllegalArgumentException("Illegal axis");
826      }
827    return span;
828  }
829
830  /**
831   * Maps a position in the document into the coordinate space of the View.
832   * The output rectangle usually reflects the font height but has a width
833   * of zero.
834   *
835   * @param pos the position of the character in the model
836   * @param a the area that is occupied by the view
837   * @param b either {@link Position.Bias#Forward} or
838   *        {@link Position.Bias#Backward} depending on the preferred
839   *        direction bias. If <code>null</code> this defaults to
840   *        <code>Position.Bias.Forward</code>
841   *
842   * @return a rectangle that gives the location of the document position
843   *         inside the view coordinate space
844   *
845   * @throws BadLocationException if <code>pos</code> is invalid
846   * @throws IllegalArgumentException if b is not one of the above listed
847   *         valid values
848   */
849  public Shape modelToView(int pos, Shape a, Position.Bias b)
850    throws BadLocationException
851  {
852    GlyphPainter p = getGlyphPainter();
853    return p.modelToView(this, pos, b, a);
854  }
855
856  /**
857   * Maps coordinates from the <code>View</code>'s space into a position
858   * in the document model.
859   *
860   * @param x the x coordinate in the view space
861   * @param y the y coordinate in the view space
862   * @param a the allocation of this <code>View</code>
863   * @param b the bias to use
864   *
865   * @return the position in the document that corresponds to the screen
866   *         coordinates <code>x, y</code>
867   */
868  public int viewToModel(float x, float y, Shape a, Position.Bias[] b)
869  {
870    checkPainter();
871    GlyphPainter painter = getGlyphPainter();
872    return painter.viewToModel(this, x, y, a, b);
873  }
874
875  /**
876   * Return the {@link TabExpander} to use.
877   *
878   * @return the {@link TabExpander} to use
879   */
880  public TabExpander getTabExpander()
881  {
882    return tabExpander;
883  }
884
885  /**
886   * Returns the preferred span of this view for tab expansion.
887   *
888   * @param x the location of the view
889   * @param te the tab expander to use
890   *
891   * @return the preferred span of this view for tab expansion
892   */
893  public float getTabbedSpan(float x, TabExpander te)
894  {
895    checkPainter();
896    TabExpander old = tabExpander;
897    tabExpander = te;
898    if (tabExpander != old)
899      {
900        // Changing the tab expander will lead to a relayout in the X_AXIS.
901        preferenceChanged(null, true, false);
902      }
903    tabX = x;
904    return getGlyphPainter().getSpan(this, getStartOffset(),
905                                     getEndOffset(), tabExpander, x);
906  }
907
908  /**
909   * Returns the span of a portion of the view. This is used in TAB expansion
910   * for fragments that don't contain TABs.
911   *
912   * @param p0 the start index
913   * @param p1 the end index
914   *
915   * @return the span of the specified portion of the view
916   */
917  public float getPartialSpan(int p0, int p1)
918  {
919    checkPainter();
920    return glyphPainter.getSpan(this, p0, p1, tabExpander, tabX);
921  }
922
923  /**
924   * Returns the start offset in the document model of the portion
925   * of text that this view is responsible for.
926   *
927   * @return the start offset in the document model of the portion
928   *         of text that this view is responsible for
929   */
930  public int getStartOffset()
931  {
932    Element el = getElement();
933    int offs = el.getStartOffset();
934    if (length > 0)
935      offs += offset;
936    return offs;
937  }
938
939  /**
940   * Returns the end offset in the document model of the portion
941   * of text that this view is responsible for.
942   *
943   * @return the end offset in the document model of the portion
944   *         of text that this view is responsible for
945   */
946  public int getEndOffset()
947  {
948    Element el = getElement();
949    int offs;
950    if (length > 0)
951      offs = el.getStartOffset() + offset + length;
952    else
953      offs = el.getEndOffset();
954    return offs;
955  }
956
957  private Segment cached = new Segment();
958
959  /**
960   * Returns the text segment that this view is responsible for.
961   *
962   * @param p0 the start index in the document model
963   * @param p1 the end index in the document model
964   *
965   * @return the text segment that this view is responsible for
966   */
967  public Segment getText(int p0, int p1)
968  {
969    try
970      {
971        getDocument().getText(p0, p1 - p0, cached);
972      }
973    catch (BadLocationException ex)
974      {
975        AssertionError ae;
976        ae = new AssertionError("BadLocationException should not be "
977                                + "thrown here. p0 = " + p0 + ", p1 = " + p1);
978        ae.initCause(ex);
979        throw ae;
980      }
981
982    return cached;
983  }
984
985  /**
986   * Returns the font for the text run for which this <code>GlyphView</code>
987   * is responsible.
988   *
989   * @return the font for the text run for which this <code>GlyphView</code>
990   *         is responsible
991   */
992  public Font getFont()
993  {
994    Document doc = getDocument();
995    Font font = null;
996    if (doc instanceof StyledDocument)
997      {
998        StyledDocument styledDoc = (StyledDocument) doc;
999        font = styledDoc.getFont(getAttributes());
1000      }
1001    else
1002      {
1003        Container c = getContainer();
1004        if (c != null)
1005          font = c.getFont();
1006      }
1007    return font;
1008  }
1009
1010  /**
1011   * Returns the foreground color which should be used to paint the text.
1012   * This is fetched from the associated element's text attributes using
1013   * {@link StyleConstants#getForeground}.
1014   *
1015   * @return the foreground color which should be used to paint the text
1016   */
1017  public Color getForeground()
1018  {
1019    Element el = getElement();
1020    AttributeSet atts = el.getAttributes();
1021    return StyleConstants.getForeground(atts);
1022  }
1023
1024  /**
1025   * Returns the background color which should be used to paint the text.
1026   * This is fetched from the associated element's text attributes using
1027   * {@link StyleConstants#getBackground}.
1028   *
1029   * @return the background color which should be used to paint the text
1030   */
1031  public Color getBackground()
1032  {
1033    Element el = getElement();
1034    AttributeSet atts = el.getAttributes();
1035    // We cannot use StyleConstants.getBackground() here, because that returns
1036    // BLACK as default (when background == null). What we need is the
1037    // background setting of the text component instead, which is what we get
1038    // when background == null anyway.
1039    return (Color) atts.getAttribute(StyleConstants.Background);
1040  }
1041
1042  /**
1043   * Determines whether the text should be rendered strike-through or not. This
1044   * is determined using the method
1045   * {@link StyleConstants#isStrikeThrough(AttributeSet)} on the element of
1046   * this view.
1047   *
1048   * @return whether the text should be rendered strike-through or not
1049   */
1050  public boolean isStrikeThrough()
1051  {
1052    Element el = getElement();
1053    AttributeSet atts = el.getAttributes();
1054    return StyleConstants.isStrikeThrough(atts);
1055  }
1056
1057  /**
1058   * Determines whether the text should be rendered as subscript or not. This
1059   * is determined using the method
1060   * {@link StyleConstants#isSubscript(AttributeSet)} on the element of
1061   * this view.
1062   *
1063   * @return whether the text should be rendered as subscript or not
1064   */
1065  public boolean isSubscript()
1066  {
1067    Element el = getElement();
1068    AttributeSet atts = el.getAttributes();
1069    return StyleConstants.isSubscript(atts);
1070  }
1071
1072  /**
1073   * Determines whether the text should be rendered as superscript or not. This
1074   * is determined using the method
1075   * {@link StyleConstants#isSuperscript(AttributeSet)} on the element of
1076   * this view.
1077   *
1078   * @return whether the text should be rendered as superscript or not
1079   */
1080  public boolean isSuperscript()
1081  {
1082    Element el = getElement();
1083    AttributeSet atts = el.getAttributes();
1084    return StyleConstants.isSuperscript(atts);
1085  }
1086
1087  /**
1088   * Determines whether the text should be rendered as underlined or not. This
1089   * is determined using the method
1090   * {@link StyleConstants#isUnderline(AttributeSet)} on the element of
1091   * this view.
1092   *
1093   * @return whether the text should be rendered as underlined or not
1094   */
1095  public boolean isUnderline()
1096  {
1097    Element el = getElement();
1098    AttributeSet atts = el.getAttributes();
1099    return StyleConstants.isUnderline(atts);
1100  }
1101
1102  /**
1103   * Creates and returns a shallow clone of this GlyphView. This is used by
1104   * the {@link #createFragment} and {@link #breakView} methods.
1105   *
1106   * @return a shallow clone of this GlyphView
1107   */
1108  protected final Object clone()
1109  {
1110    try
1111      {
1112        return super.clone();
1113      }
1114    catch (CloneNotSupportedException ex)
1115      {
1116        AssertionError err = new AssertionError("CloneNotSupportedException "
1117                                                + "must not be thrown here");
1118        err.initCause(ex);
1119        throw err;
1120      }
1121  }
1122
1123  /**
1124   * Tries to break the view near the specified view span <code>len</code>.
1125   * The glyph view can only be broken in the X direction. For Y direction it
1126   * returns itself.
1127   *
1128   * @param axis the axis for breaking, may be {@link View#X_AXIS} or
1129   *        {@link View#Y_AXIS}
1130   * @param p0 the model location where the fragment should start
1131   * @param pos the view position along the axis where the fragment starts
1132   * @param len the desired length of the fragment view
1133   *
1134   * @return the fragment view, or <code>this</code> if breaking was not
1135   *         possible
1136   */
1137  public View breakView(int axis, int p0, float pos, float len)
1138  {
1139    View brokenView = this;
1140    if (axis == X_AXIS)
1141      {
1142        checkPainter();
1143        int end = glyphPainter.getBoundedPosition(this, p0, pos, len);
1144        int breakLoc = getBreakLocation(p0, end);
1145        if (breakLoc != -1)
1146          end = breakLoc;
1147        if (p0 != getStartOffset() || end != getEndOffset())
1148          {
1149            brokenView = createFragment(p0, end);
1150            if (brokenView instanceof GlyphView)
1151              ((GlyphView) brokenView).tabX = pos;
1152          }
1153      }
1154    return brokenView;
1155  }
1156
1157  /**
1158   * Determines how well the specified view location is suitable for inserting
1159   * a line break. If <code>axis</code> is <code>View.Y_AXIS</code>, then
1160   * this method forwards to the superclass, if <code>axis</code> is
1161   * <code>View.X_AXIS</code> then this method returns
1162   * {@link View#ExcellentBreakWeight} if there is a suitable break location
1163   * (usually whitespace) within the specified view span, or
1164   * {@link View#GoodBreakWeight} if not.
1165   *
1166   * @param axis the axis along which the break weight is requested
1167   * @param pos the starting view location
1168   * @param len the length of the span at which the view should be broken
1169   *
1170   * @return the break weight
1171   */
1172  public int getBreakWeight(int axis, float pos, float len)
1173  {
1174    int weight;
1175    if (axis == Y_AXIS)
1176      weight = super.getBreakWeight(axis, pos, len);
1177    else
1178      {
1179        checkPainter();
1180        int start = getStartOffset();
1181        int end = glyphPainter.getBoundedPosition(this, start, pos, len);
1182        if (end == 0)
1183          weight = BadBreakWeight;
1184        else
1185          {
1186            if (getBreakLocation(start, end) != -1)
1187              weight = ExcellentBreakWeight;
1188            else
1189              weight = GoodBreakWeight;
1190          }
1191      }
1192    return weight;
1193  }
1194
1195  private int getBreakLocation(int start, int end)
1196  {
1197    int loc = -1;
1198    Segment s = getText(start, end);
1199    for (char c = s.last(); c != Segment.DONE && loc == -1; c = s.previous())
1200      {
1201        if (Character.isWhitespace(c))
1202          {
1203            loc = s.getIndex() - s.getBeginIndex() + 1 + start;
1204          }
1205      }
1206    return loc;
1207  }
1208
1209  /**
1210   * Receives notification that some text attributes have changed within the
1211   * text fragment that this view is responsible for. This calls
1212   * {@link View#preferenceChanged(View, boolean, boolean)} on the parent for
1213   * both width and height.
1214   *
1215   * @param e the document event describing the change; not used here
1216   * @param a the view allocation on screen; not used here
1217   * @param vf the view factory; not used here
1218   */
1219  public void changedUpdate(DocumentEvent e, Shape a, ViewFactory vf)
1220  {
1221    preferenceChanged(null, true, true);
1222  }
1223
1224  /**
1225   * Receives notification that some text has been inserted within the
1226   * text fragment that this view is responsible for. This calls
1227   * {@link View#preferenceChanged(View, boolean, boolean)} for the
1228   * direction in which the glyphs are rendered.
1229   *
1230   * @param e the document event describing the change; not used here
1231   * @param a the view allocation on screen; not used here
1232   * @param vf the view factory; not used here
1233   */
1234  public void insertUpdate(DocumentEvent e, Shape a, ViewFactory vf)
1235  {
1236    preferenceChanged(null, true, false);
1237  }
1238
1239  /**
1240   * Receives notification that some text has been removed within the
1241   * text fragment that this view is responsible for. This calls
1242   * {@link View#preferenceChanged(View, boolean, boolean)} on the parent for
1243   * width.
1244   *
1245   * @param e the document event describing the change; not used here
1246   * @param a the view allocation on screen; not used here
1247   * @param vf the view factory; not used here
1248   */
1249  public void removeUpdate(DocumentEvent e, Shape a, ViewFactory vf)
1250  {
1251    preferenceChanged(null, true, false);
1252  }
1253
1254  /**
1255   * Creates a fragment view of this view that starts at <code>p0</code> and
1256   * ends at <code>p1</code>.
1257   *
1258   * @param p0 the start location for the fragment view
1259   * @param p1 the end location for the fragment view
1260   *
1261   * @return the fragment view
1262   */
1263  public View createFragment(int p0, int p1)
1264  {
1265    checkPainter();
1266    Element el = getElement();
1267    GlyphView fragment = (GlyphView) clone();
1268    fragment.offset = p0 - el.getStartOffset();
1269    fragment.length = p1 - p0;
1270    fragment.glyphPainter = glyphPainter.getPainter(fragment, p0, p1);
1271    return fragment;
1272  }
1273
1274  /**
1275   * Returns the alignment of this view along the specified axis. For the Y
1276   * axis this is <code>(height - descent) / height</code> for the used font,
1277   * so that it is aligned along the baseline.
1278   * For the X axis the superclass is called.
1279   */
1280  public float getAlignment(int axis)
1281  {
1282    checkPainter();
1283    float align;
1284    if (axis == Y_AXIS)
1285      {
1286        GlyphPainter painter = getGlyphPainter();
1287        float height = painter.getHeight(this);
1288        float descent = painter.getDescent(this);
1289        float ascent = painter.getAscent(this);
1290        if (isSuperscript())
1291          align = 1.0F;
1292        else if (isSubscript())
1293          align = height > 0 ? (height - (descent + (ascent / 2))) / height
1294                             : 0;
1295        else
1296          align = height > 0 ? (height - descent) / height : 0;
1297      }
1298    else
1299      align = super.getAlignment(axis);
1300
1301    return align;
1302  }
1303
1304  /**
1305   * Returns the model location that should be used to place a caret when
1306   * moving the caret through the document.
1307   *
1308   * @param pos the current model location
1309   * @param bias the bias for <code>p</code>
1310   * @param a the allocated region for the glyph view
1311   * @param direction the direction from the current position; Must be one of
1312   *        {@link SwingConstants#EAST}, {@link SwingConstants#WEST},
1313   *        {@link SwingConstants#NORTH} or {@link SwingConstants#SOUTH}
1314   * @param biasRet filled with the bias of the resulting location when method
1315   *        returns
1316   *
1317   * @return the location within the document that should be used to place the
1318   *         caret when moving the caret around the document
1319   *
1320   * @throws BadLocationException if <code>pos</code> is an invalid model
1321   *         location
1322   * @throws IllegalArgumentException if <code>d</code> is invalid
1323   */
1324  public int getNextVisualPositionFrom(int pos, Position.Bias bias, Shape a,
1325                                       int direction, Position.Bias[] biasRet)
1326    throws BadLocationException
1327  {
1328    checkPainter();
1329    GlyphPainter painter = getGlyphPainter();
1330    return painter.getNextVisualPositionFrom(this, pos, bias, a, direction,
1331                                             biasRet);
1332  }
1333}