libjava/javax/swing/plaf/basic/BasicTextUI.java

   1 /* BasicTextUI.java --
   2    Copyright (C) 2002, 2003, 2004, 2005  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 javax.swing.plaf.basic;
  40
  41 import java.awt.Container;
  42 import java.awt.Dimension;
  43 import java.awt.Graphics;
  44 import java.awt.Insets;
  45 import java.awt.Point;
  46 import java.awt.Rectangle;
  47 import java.awt.Shape;
  48 import java.awt.event.FocusEvent;
  49 import java.awt.event.FocusListener;
  50 import java.beans.PropertyChangeEvent;
  51 import java.beans.PropertyChangeListener;
  52
  53 import javax.swing.Action;
  54 import javax.swing.ActionMap;
  55 import javax.swing.InputMap;
  56 import javax.swing.JComponent;
  57 import javax.swing.SwingUtilities;
  58 import javax.swing.UIDefaults;
  59 import javax.swing.UIManager;
  60 import javax.swing.plaf.TextUI;
  61 import javax.swing.plaf.UIResource;
  62 import javax.swing.text.BadLocationException;
  63 import javax.swing.text.Caret;
  64 import javax.swing.text.DefaultCaret;
  65 import javax.swing.text.DefaultEditorKit;
  66 import javax.swing.text.DefaultHighlighter;
  67 import javax.swing.text.Document;
  68 import javax.swing.text.EditorKit;
  69 import javax.swing.text.Element;
  70 import javax.swing.text.Highlighter;
  71 import javax.swing.text.JTextComponent;
  72 import javax.swing.text.Keymap;
  73 import javax.swing.text.PlainView;
  74 import javax.swing.text.Position;
  75 import javax.swing.text.View;
  76 import javax.swing.text.ViewFactory;
  77
  78
  79 public abstract class BasicTextUI extends TextUI
  80   implements ViewFactory
  81 {
  82   public static class BasicCaret extends DefaultCaret
  83     implements UIResource
  84   {
  85     public BasicCaret()
  86     {
  87     }
  88   }
  89
  90   public static class BasicHighlighter extends DefaultHighlighter
  91     implements UIResource
  92   {
  93     public BasicHighlighter()
  94     {
  95     }
  96   }
  97
  98   private class RootView extends View
  99   {
 100     private View view;
 101
 102     public RootView()
 103     {
 104       super(null);
 105     }
 106
 107     // View methods.
 108
 109     public ViewFactory getViewFactory()
 110     {
 111       // FIXME: Handle EditorKit somehow.
 112       return BasicTextUI.this;
 113     }
 114
 115     public void setView(View v)
 116     {
 117       if (view != null)
 118         view.setParent(null);
 119
 120       if (v != null)
 121         v.setParent(null);
 122
 123       view = v;
 124     }
 125
 126     public Container getContainer()
 127     {
 128       return textComponent;
 129     }
 130
 131     public float getPreferredSpan(int axis)
 132     {
 133       if (view != null)
 134         return view.getPreferredSpan(axis);
 135
 136       return Integer.MAX_VALUE;
 137     }
 138
 139     public void paint(Graphics g, Shape s)
 140     {
 141       if (view != null)
 142         view.paint(g, s);
 143     }
 144
 145     public Shape modelToView(int position, Shape a, Position.Bias bias)
 146       throws BadLocationException
 147     {
 148       if (view == null)
 149         return null;
 150
 151       return ((PlainView) view).modelToView(position, a, bias).getBounds();
 152     }
 153   }
 154
 155   class UpdateHandler implements PropertyChangeListener
 156   {
 157     public void propertyChange(PropertyChangeEvent event)
 158     {
 159       if (event.getPropertyName().equals("document"))
 160         {
 161           // Document changed.
 162           modelChanged();
 163         }
 164     }
 165   }
 166
 167   static EditorKit kit = new DefaultEditorKit();
 168
 169   RootView rootView = new RootView();
 170   JTextComponent textComponent;
 171   UpdateHandler updateHandler = new UpdateHandler();
 172
 173   public BasicTextUI()
 174   {
 175   }
 176
 177   protected Caret createCaret()
 178   {
 179     return new BasicCaret();
 180   }
 181
 182   protected Highlighter createHighlighter()
 183   {
 184     return new BasicHighlighter();
 185   }
 186
 187   protected final JTextComponent getComponent()
 188   {
 189     return textComponent;
 190   }
 191
 192   public void installUI(final JComponent c)
 193   {
 194     super.installUI(c);
 195     c.setOpaque(true);
 196
 197     textComponent = (JTextComponent) c;
 198
 199     Document doc = textComponent.getDocument();
 200     if (doc == null)
 201       {
 202         doc = getEditorKit(textComponent).createDefaultDocument();
 203         textComponent.setDocument(doc);
 204       }
 205
 206     textComponent.addPropertyChangeListener(updateHandler);
 207     modelChanged();
 208
 209     installDefaults();
 210     installListeners();
 211     installKeyboardActions();
 212   }
 213
 214   protected void installDefaults()
 215   {
 216     Caret caret = textComponent.getCaret();
 217     if (caret == null)
 218       {
 219         caret = createCaret();
 220         textComponent.setCaret(caret);
 221       }
 222
 223     Highlighter highlighter = textComponent.getHighlighter();
 224     if (highlighter == null)
 225       textComponent.setHighlighter(createHighlighter());
 226
 227     String prefix = getPropertyPrefix();
 228     UIDefaults defaults = UIManager.getLookAndFeelDefaults();
 229     textComponent.setBackground(defaults.getColor(prefix + ".background"));
 230     textComponent.setForeground(defaults.getColor(prefix + ".foreground"));
 231     textComponent.setMargin(defaults.getInsets(prefix + ".margin"));
 232     textComponent.setBorder(defaults.getBorder(prefix + ".border"));
 233     textComponent.setFont(defaults.getFont(prefix + ".font"));
 234
 235     caret.setBlinkRate(defaults.getInt(prefix + ".caretBlinkRate"));
 236   }
 237
 238   private FocusListener focuslistener = new FocusListener() {
 239       public void focusGained(FocusEvent e)
 240       {
 241         textComponent.repaint();
 242       }
 243       public void focusLost(FocusEvent e)
 244       {
 245         textComponent.repaint();
 246       }
 247     };
 248
 249   protected void installListeners()
 250   {
 251     textComponent.addFocusListener(focuslistener);
 252   }
 253
 254   protected String getKeymapName()
 255   {
 256     return "BasicTextUI";
 257   }
 258
 259   protected Keymap createKeymap()
 260   {
 261     String prefix = getPropertyPrefix();
 262     UIDefaults defaults = UIManager.getLookAndFeelDefaults();
 263     JTextComponent.KeyBinding[] bindings =
 264       (JTextComponent.KeyBinding[]) defaults.get(prefix + ".keyBindings");
 265     Keymap km = JTextComponent.addKeymap(getKeymapName(),
 266                                          JTextComponent.getKeymap(JTextComponent.DEFAULT_KEYMAP));
 267     JTextComponent.loadKeymap(km, bindings, textComponent.getActions());
 268     return km;
 269   }
 270
 271   protected void installKeyboardActions()
 272   {
 273     // load any bindings for the older Keymap interface
 274     Keymap km = JTextComponent.getKeymap(getKeymapName());
 275     if (km == null)
 276       km = createKeymap();
 277     textComponent.setKeymap(km);
 278
 279     // load any bindings for the newer InputMap / ActionMap interface
 280     SwingUtilities.replaceUIInputMap(textComponent,
 281                                      JComponent.WHEN_FOCUSED,
 282                                      getInputMap(JComponent.WHEN_FOCUSED));
 283     SwingUtilities.replaceUIActionMap(textComponent, getActionMap());
 284   }
 285
 286   InputMap getInputMap(int condition)
 287   {
 288     String prefix = getPropertyPrefix();
 289     UIDefaults defaults = UIManager.getLookAndFeelDefaults();
 290     switch (condition)
 291       {
 292       case JComponent.WHEN_IN_FOCUSED_WINDOW:
 293         // FIXME: is this the right string? nobody seems to use it.
 294         return (InputMap) defaults.get(prefix + ".windowInputMap");
 295       case JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT:
 296         return (InputMap) defaults.get(prefix + ".ancestorInputMap");
 297       default:
 298       case JComponent.WHEN_FOCUSED:
 299         return (InputMap) defaults.get(prefix + ".focusInputMap");
 300       }
 301   }
 302
 303   ActionMap getActionMap()
 304   {
 305     String prefix = getPropertyPrefix();
 306     UIDefaults defaults = UIManager.getLookAndFeelDefaults();
 307     ActionMap am = (ActionMap) defaults.get(prefix + ".actionMap");
 308     if (am == null)
 309       {
 310         am = createActionMap();
 311         defaults.put(prefix + ".actionMap", am);
 312       }
 313     return am;
 314   }
 315
 316   ActionMap createActionMap()
 317   {
 318     Action[] actions = textComponent.getActions();
 319     ActionMap am = new ActionMap();
 320     for (int i = 0; i < actions.length; ++i)
 321       {
 322         String name = (String) actions[i].getValue(Action.NAME);
 323         if (name != null)
 324           am.put(name, actions[i]);
 325       }
 326     return am;
 327   }
 328
 329   public void uninstallUI(final JComponent component)
 330   {
 331     super.uninstallUI(component);
 332     rootView.setView(null);
 333
 334     textComponent.removePropertyChangeListener(updateHandler);
 335
 336     uninstallDefaults();
 337     uninstallListeners();
 338     uninstallKeyboardActions();
 339
 340     textComponent = null;
 341   }
 342
 343   protected void uninstallDefaults()
 344   {
 345     // Do nothing here.
 346   }
 347
 348   protected void uninstallListeners()
 349   {
 350     textComponent.removeFocusListener(focuslistener);
 351   }
 352
 353   protected void uninstallKeyboardActions()
 354   {
 355     // Do nothing here.
 356   }
 357
 358   protected abstract String getPropertyPrefix();
 359
 360   public Dimension getPreferredSize(JComponent c)
 361   {
 362     View v = getRootView(textComponent);
 363
 364     float w = v.getPreferredSpan(View.X_AXIS);
 365     float h = v.getPreferredSpan(View.Y_AXIS);
 366
 367     return new Dimension((int) w, (int) h);
 368   }
 369
 370   public final void paint(Graphics g, JComponent c)
 371   {
 372     paintSafely(g);
 373   }
 374
 375   protected void paintSafely(Graphics g)
 376   {
 377     Caret caret = textComponent.getCaret();
 378     Highlighter highlighter = textComponent.getHighlighter();
 379
 380     if (textComponent.isOpaque())
 381       paintBackground(g);
 382
 383     if (highlighter != null
 384         && textComponent.getSelectionStart() != textComponent.getSelectionEnd())
 385       highlighter.paint(g);
 386
 387     rootView.paint(g, getVisibleEditorRect());
 388
 389     if (caret != null && textComponent.hasFocus())
 390       caret.paint(g);
 391   }
 392
 393   protected void paintBackground(Graphics g)
 394   {
 395     g.setColor(textComponent.getBackground());
 396     g.fillRect(0, 0, textComponent.getWidth(), textComponent.getHeight());
 397   }
 398
 399   public void damageRange(JTextComponent t, int p0, int p1)
 400   {
 401     damageRange(t, p0, p1, null, null);
 402   }
 403
 404   public void damageRange(JTextComponent t, int p0, int p1,
 405                           Position.Bias firstBias, Position.Bias secondBias)
 406   {
 407   }
 408
 409   public EditorKit getEditorKit(JTextComponent t)
 410   {
 411     return kit;
 412   }
 413
 414   public int getNextVisualPositionFrom(JTextComponent t, int pos,
 415                                        Position.Bias b, int direction,
 416                                        Position.Bias[] biasRet)
 417     throws BadLocationException
 418   {
 419     return 0;
 420   }
 421
 422   public View getRootView(JTextComponent t)
 423   {
 424     return rootView;
 425   }
 426
 427   public Rectangle modelToView(JTextComponent t, int pos)
 428     throws BadLocationException
 429   {
 430     return modelToView(t, pos, Position.Bias.Forward);
 431   }
 432
 433   public Rectangle modelToView(JTextComponent t, int pos, Position.Bias bias)
 434     throws BadLocationException
 435   {
 436     return rootView.modelToView(pos, getVisibleEditorRect(), bias).getBounds();
 437   }
 438
 439   public int viewToModel(JTextComponent t, Point pt)
 440   {
 441     return viewToModel(t, pt, null);
 442   }
 443
 444   public int viewToModel(JTextComponent t, Point pt, Position.Bias[] biasReturn)
 445   {
 446     return 0;
 447   }
 448
 449   public View create(Element elem)
 450   {
 451     // Subclasses have to implement this to get this functionality.
 452     return null;
 453   }
 454
 455   public View create(Element elem, int p0, int p1)
 456   {
 457     // Subclasses have to implement this to get this functionality.
 458     return null;
 459   }
 460
 461   protected Rectangle getVisibleEditorRect()
 462   {
 463     int width = textComponent.getWidth();
 464     int height = textComponent.getHeight();
 465
 466     if (width <= 0 || height <= 0)
 467       return null;
 468
 469     Insets insets = textComponent.getInsets();
 470     return new Rectangle(insets.left, insets.top,
 471                          width - insets.left + insets.right,
 472                          height - insets.top + insets.bottom);
 473   }
 474
 475   protected final void setView(View view)
 476   {
 477     rootView.setView(view);
 478     view.setParent(rootView);
 479   }
 480
 481   protected void modelChanged()
 482   {
 483     if (textComponent == null || rootView == null)
 484       return;
 485     ViewFactory factory = rootView.getViewFactory();
 486     if (factory == null)
 487       return;
 488     Document doc = textComponent.getDocument();
 489     if (doc == null)
 490       return;
 491     Element elem = doc.getDefaultRootElement();
 492     if (elem == null)
 493       return;
 494     setView(factory.create(elem));
 495   }
 496 }