libjava/java/awt/font/TextLayout.java

   1 /* TextLayout.java
   2    Copyright (C) 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.font;
  40
  41 import java.awt.Font;
  42 import java.awt.Graphics2D;
  43 import java.awt.Shape;
  44 import java.awt.geom.AffineTransform;
  45 import java.awt.geom.Rectangle2D;
  46 import java.text.CharacterIterator;
  47 import java.text.AttributedCharacterIterator;
  48 import java.text.AttributedString;
  49 import java.util.Map;
  50 import java.awt.font.TextAttribute;
  51
  52
  53 /**
  54  * @author Michael Koch
  55  */
  56 public final class TextLayout implements Cloneable
  57 {
  58   public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy ();
  59
  60   public static class CaretPolicy
  61   {
  62     public CaretPolicy ()
  63     {
  64       // Do nothing here.
  65     }
  66
  67     public TextHitInfo getStrongCaret (TextHitInfo hit1, TextHitInfo hit2,
  68                                        TextLayout layout)
  69     {
  70       throw new Error ("not implemented");
  71     }
  72   }
  73
  74   private AttributedString attributedString;
  75   private FontRenderContext fontRenderContext;
  76
  77   public TextLayout (AttributedCharacterIterator text, FontRenderContext frc)
  78   {
  79     attributedString = new AttributedString (text);
  80     fontRenderContext = frc;
  81   }
  82
  83   public TextLayout (String string, Font font, FontRenderContext frc)
  84   {
  85     attributedString = new AttributedString (string);
  86     attributedString.addAttribute (TextAttribute.FONT, font);
  87     fontRenderContext = frc;
  88   }
  89
  90   public TextLayout (String string, Map attributes, FontRenderContext frc)
  91   {
  92     attributedString = new AttributedString (string, attributes);
  93     fontRenderContext = frc;
  94   }
  95
  96   protected Object clone ()
  97   {
  98     try
  99       {
 100         return super.clone ();
 101       }
 102     catch (CloneNotSupportedException e)
 103       {
 104         // This should never occur
 105         throw new InternalError ();
 106       }
 107   }
 108
 109
 110   protected class CharacterIteratorProxy
 111     implements CharacterIterator
 112   {
 113     public CharacterIterator target;
 114     public int begin;
 115     public int limit;
 116     public int index;
 117
 118     public CharacterIteratorProxy (CharacterIterator ci)
 119     {
 120       target = ci;
 121     }
 122
 123     public int getBeginIndex ()
 124     {
 125       return begin;
 126     }
 127
 128     public int getEndIndex ()
 129     {
 130       return limit;
 131     }
 132
 133     public int getIndex ()
 134     {
 135       return index;
 136     }
 137
 138     public char setIndex (int idx)
 139       throws IllegalArgumentException
 140     {
 141       if (idx < begin || idx >= limit)
 142         throw new IllegalArgumentException ();
 143       char ch = target.setIndex (idx);
 144       index = idx;
 145       return ch;
 146     }
 147
 148     public char first ()
 149     {
 150       int save = target.getIndex ();
 151       char ch = target.setIndex (begin);
 152       target.setIndex (save);
 153       return ch;
 154     }
 155
 156     public char last ()
 157     {
 158       if (begin == limit)
 159         return this.first ();
 160
 161       int save = target.getIndex ();
 162       char ch = target.setIndex (limit - 1);
 163       target.setIndex (save);
 164       return ch;
 165     }
 166
 167     public char current ()
 168     {
 169       return target.current();
 170     }
 171
 172     public char next ()
 173     {
 174       if (index >= limit - 1)
 175         return CharacterIterator.DONE;
 176       else
 177         {
 178           index++;
 179           return target.next();
 180         }
 181     }
 182
 183     public char previous ()
 184     {
 185       if (index <= begin)
 186         return CharacterIterator.DONE;
 187       else
 188         {
 189           index--;
 190           return target.previous ();
 191         }
 192     }
 193
 194     public Object clone ()
 195     {
 196       CharacterIteratorProxy cip = new CharacterIteratorProxy (this.target);
 197       cip.begin = this.begin;
 198       cip.limit = this.limit;
 199       cip.index = this.index;
 200       return cip;
 201     }
 202
 203   }
 204
 205
 206   public void draw (Graphics2D g2, float x, float y)
 207   {
 208     AttributedCharacterIterator ci = attributedString.getIterator ();
 209     CharacterIteratorProxy proxy = new CharacterIteratorProxy (ci);
 210     Font defFont = g2.getFont ();
 211
 212     /* Note: this implementation currently only interprets FONT text
 213      * attributes. There is a reasonable argument to be made for some
 214      * attributes being interpreted out here, where we have control of the
 215      * Graphics2D and can construct or derive new fonts, and some
 216      * attributes being interpreted by the GlyphVector itself. So far, for
 217      * all attributes except FONT we do neither.
 218      */
 219
 220     for (char c = ci.first ();
 221          c != CharacterIterator.DONE;
 222          c = ci.next ())
 223       {
 224         proxy.begin = ci.getIndex ();
 225         proxy.limit = ci.getRunLimit(TextAttribute.FONT);
 226         if (proxy.limit <= proxy.begin)
 227           continue;
 228
 229         proxy.index = proxy.begin;
 230
 231         Object fnt = ci.getAttribute(TextAttribute.FONT);
 232         GlyphVector gv;
 233         if (fnt instanceof Font)
 234           gv = ((Font)fnt).createGlyphVector (fontRenderContext, proxy);
 235         else
 236           gv = defFont.createGlyphVector (fontRenderContext, proxy);
 237
 238         g2.drawGlyphVector (gv, x, y);
 239
 240         int n = gv.getNumGlyphs ();
 241         for (int i = 0; i < n; ++i)
 242           {
 243             GlyphMetrics gm = gv.getGlyphMetrics (i);
 244             if (gm.getAdvanceX() == gm.getAdvance ())
 245               x += gm.getAdvanceX ();
 246             else
 247               y += gm.getAdvanceY ();
 248           }
 249       }
 250   }
 251
 252   public boolean equals (Object obj)
 253   {
 254     if (! (obj instanceof TextLayout))
 255       return false;
 256
 257     return equals ((TextLayout) obj);
 258   }
 259
 260   public boolean equals (TextLayout tl)
 261   {
 262     throw new Error ("not implemented");
 263   }
 264
 265   public float getAdvance ()
 266   {
 267     throw new Error ("not implemented");
 268   }
 269
 270   public float getAscent ()
 271   {
 272     throw new Error ("not implemented");
 273   }
 274
 275   public byte getBaseline ()
 276   {
 277     throw new Error ("not implemented");
 278   }
 279
 280   public float[] getBaselineOffsets ()
 281   {
 282     throw new Error ("not implemented");
 283   }
 284
 285   public Shape getBlackBoxBounds (int firstEndpoint, int secondEndpoint)
 286   {
 287     throw new Error ("not implemented");
 288   }
 289
 290   public Rectangle2D getBounds()
 291   {
 292     throw new Error ("not implemented");
 293   }
 294
 295   public float[] getCaretInfo (TextHitInfo hit)
 296   {
 297     throw new Error ("not implemented");
 298   }
 299
 300   public float[] getCaretInfo (TextHitInfo hit, Rectangle2D bounds)
 301   {
 302     throw new Error ("not implemented");
 303   }
 304
 305   public Shape getCaretShape (TextHitInfo hit)
 306   {
 307     throw new Error ("not implemented");
 308   }
 309
 310   public Shape getCaretShape (TextHitInfo hit, Rectangle2D bounds)
 311   {
 312     throw new Error ("not implemented");
 313   }
 314
 315   public Shape[] getCaretShapes (int offset)
 316   {
 317     throw new Error ("not implemented");
 318   }
 319
 320   public Shape[] getCaretShapes (int offset, Rectangle2D bounds)
 321   {
 322     throw new Error ("not implemented");
 323   }
 324
 325   public Shape[] getCaretShapes (int offset, Rectangle2D bounds,
 326                                  TextLayout.CaretPolicy policy)
 327   {
 328     throw new Error ("not implemented");
 329   }
 330
 331   public int getCharacterCount ()
 332   {
 333     throw new Error ("not implemented");
 334   }
 335
 336   public byte getCharacterLevel (int index)
 337   {
 338     throw new Error ("not implemented");
 339   }
 340
 341   public float getDescent ()
 342   {
 343     throw new Error ("not implemented");
 344   }
 345
 346   public TextLayout getJustifiedLayout (float justificationWidth)
 347   {
 348     throw new Error ("not implemented");
 349   }
 350
 351   public float getLeading ()
 352   {
 353     throw new Error ("not implemented");
 354   }
 355
 356   public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint)
 357   {
 358     throw new Error ("not implemented");
 359   }
 360
 361   public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint,
 362                                          Rectangle2D bounds)
 363   {
 364     throw new Error ("not implemented");
 365   }
 366
 367   public int[] getLogicalRangesForVisualSelection (TextHitInfo firstEndpoint,
 368                                                    TextHitInfo secondEndpoint)
 369   {
 370     throw new Error ("not implemented");
 371   }
 372
 373   public TextHitInfo getNextLeftHit (int offset)
 374   {
 375     throw new Error ("not implemented");
 376   }
 377
 378   public TextHitInfo getNextLeftHit (int offset, TextLayout.CaretPolicy policy)
 379   {
 380     throw new Error ("not implemented");
 381   }
 382
 383   public TextHitInfo getNextLeftHit (TextHitInfo hit)
 384   {
 385     throw new Error ("not implemented");
 386   }
 387
 388   public TextHitInfo getNextRightHit (int offset)
 389   {
 390     throw new Error ("not implemented");
 391   }
 392
 393   public TextHitInfo getNextRightHit (int offset, TextLayout.CaretPolicy policy)
 394   {
 395     throw new Error ("not implemented");
 396   }
 397
 398   public TextHitInfo getNextRightHit (TextHitInfo hit)
 399   {
 400     throw new Error ("not implemented");
 401   }
 402
 403   public Shape getOutline (AffineTransform tx)
 404   {
 405     throw new Error ("not implemented");
 406   }
 407
 408   public float getVisibleAdvance ()
 409   {
 410     throw new Error ("not implemented");
 411   }
 412
 413   public Shape getVisualHighlightShape (TextHitInfo firstEndpoint,
 414                                         TextHitInfo secondEndpoint)
 415   {
 416     throw new Error ("not implemented");
 417   }
 418
 419   public Shape getVisualHighlightShape (TextHitInfo firstEndpoint,
 420                                         TextHitInfo secondEndpoint,
 421                                         Rectangle2D bounds)
 422   {
 423     throw new Error ("not implemented");
 424   }
 425
 426   public TextHitInfo getVisualOtherHit (TextHitInfo hit)
 427   {
 428     throw new Error ("not implemented");
 429   }
 430
 431   protected void handleJustify (float justificationWidth)
 432   {
 433     throw new Error ("not implemented");
 434   }
 435
 436   public int hashCode ()
 437   {
 438     throw new Error ("not implemented");
 439   }
 440
 441   public TextHitInfo hitTestChar (float x, float y)
 442   {
 443     throw new Error ("not implemented");
 444   }
 445
 446   public TextHitInfo hitTestChar (float x, float y, Rectangle2D bounds)
 447   {
 448     throw new Error ("not implemented");
 449   }
 450
 451   public boolean isLeftToRight ()
 452   {
 453     throw new Error ("not implemented");
 454   }
 455
 456   public boolean isVertical ()
 457   {
 458     throw new Error ("not implemented");
 459   }
 460
 461   public String toString ()
 462   {
 463     throw new Error ("not implemented");
 464   }
 465 }