libjava/javax/swing/JEditorPane.java

   1 /* JEditorPane.java --
   2    Copyright (C) 2002, 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;
  40
  41 import java.awt.Dimension;
  42 import java.awt.event.KeyEvent;
  43 import java.io.IOException;
  44 import java.io.InputStream;
  45 import java.net.URL;
  46
  47 import javax.accessibility.AccessibleContext;
  48 import javax.swing.event.HyperlinkEvent;
  49 import javax.swing.event.HyperlinkListener;
  50 import javax.swing.text.BadLocationException;
  51 import javax.swing.text.DefaultEditorKit;
  52 import javax.swing.text.EditorKit;
  53 import javax.swing.text.JTextComponent;
  54
  55
  56 public class JEditorPane extends JTextComponent
  57 {
  58   private static final long serialVersionUID = 3140472492599046285L;
  59
  60   private URL page;
  61   private EditorKit editorKit;
  62
  63   boolean focus_root;
  64   boolean manages_focus;
  65
  66   public JEditorPane()
  67   {
  68     setEditorKit(createDefaultEditorKit());
  69   }
  70
  71   public JEditorPane(String url) throws IOException
  72   {
  73     this(new URL(url));
  74   }
  75
  76   public JEditorPane(String type, String text)
  77   {
  78     setEditorKit(createEditorKitForContentType(type));
  79     setText(text);
  80   }
  81
  82   public JEditorPane(URL url) throws IOException
  83   {
  84     this();
  85     setPage(url);
  86   }
  87
  88   protected EditorKit createDefaultEditorKit()
  89   {
  90     return new DefaultEditorKit();
  91   }
  92
  93   public static EditorKit createEditorKitForContentType(String type)
  94   {
  95     return new DefaultEditorKit();
  96   }
  97
  98   /**
  99    * Sends a given <code>HyperlinkEvent</code> to all registered listeners.
 100    *
 101    * @param event the event to send
 102    */
 103   public void fireHyperlinkUpdate(HyperlinkEvent event)
 104   {
 105     HyperlinkListener[] listeners = getHyperlinkListeners();
 106
 107     for (int index = 0; index < listeners.length; ++index)
 108        listeners[index].hyperlinkUpdate(event);
 109   }
 110
 111   public AccessibleContext getAccessibleContext()
 112   {
 113     return null;
 114   }
 115
 116   public final String getContentType()
 117   {
 118     return getEditorKit().getContentType();
 119   }
 120
 121   public EditorKit getEditorKit()
 122   {
 123     return editorKit;
 124   }
 125
 126   public static String getEditorKitClassNameForContentType(String type)
 127   {
 128     return "text/plain";
 129   }
 130
 131   public EditorKit getEditorKitForContentType(String type)
 132   {
 133     return editorKit;
 134   }
 135
 136   /**
 137    * Returns the preferred size for the JEditorPane.
 138    */
 139   public Dimension getPreferredSize()
 140   {
 141     return super.getPreferredSize();
 142   }
 143
 144   public boolean getScrollableTracksViewportHeight()
 145   {
 146     return false;
 147   }
 148
 149   public boolean getScrollableTracksViewportWidth()
 150   {
 151     return false;
 152   }
 153
 154   public URL getPage()
 155   {
 156     return page;
 157   }
 158
 159   protected InputStream getStream(URL page)
 160     throws IOException
 161   {
 162     return page.openStream();
 163   }
 164
 165   public String getText()
 166   {
 167     return super.getText();
 168   }
 169
 170   public String getUIClassID()
 171   {
 172     return "EditorPaneUI";
 173   }
 174
 175   public boolean isFocusCycleRoot()
 176   {
 177     return focus_root;
 178   }
 179
 180   public boolean isManagingFocus()
 181   {
 182     return manages_focus;
 183   }
 184
 185   protected String paramString()
 186   {
 187     return "JEditorPane";
 188   }
 189
 190   /**
 191    * Overridden to handle processing of tab/shift tab.
 192    */
 193   protected void processComponentKeyEvent(KeyEvent e)
 194   {
 195   }
 196
 197   /**
 198    * Make sure that TAB and Shift-TAB events get consumed,
 199    * so that awt doesn't attempt focus traversal.
 200    */
 201   protected void processKeyEvent(KeyEvent e)
 202   {
 203   }
 204
 205   /**
 206    * This method initializes from a stream.
 207    */
 208   public void read(InputStream in, Object desc)
 209     throws IOException
 210   {
 211   }
 212
 213   /**
 214    * Establishes the default bindings of type to classname.
 215    */
 216   public static void registerEditorKitForContentType(String type,
 217                                                      String classname)
 218   {
 219   }
 220
 221   /**
 222    * Establishes the default bindings of type to classname.
 223    */
 224   public static void registerEditorKitForContentType(String type,
 225                                                      String classname,
 226                                                      ClassLoader loader)
 227   {
 228   }
 229
 230   /**
 231    * Replaces the currently selected content with new content represented
 232    * by the given string.
 233    */
 234   public void replaceSelection(String content)
 235   {
 236   }
 237
 238   /**
 239    * Scrolls the view to the given reference location (that is, the value
 240    * returned by the UL.getRef method for the URL being displayed).
 241    */
 242   public void scrollToReference(String reference)
 243   {
 244   }
 245
 246   public final void setContentType(String type)
 247   {
 248     if (editorKit != null
 249         && editorKit.getContentType().equals(type))
 250       return;
 251
 252     EditorKit kit = getEditorKitForContentType(type);
 253
 254     if (kit != null)
 255       setEditorKit(kit);
 256   }
 257
 258   public void setEditorKit(EditorKit newValue)
 259   {
 260     if (editorKit == newValue)
 261       return;
 262
 263     if (editorKit != null)
 264       editorKit.deinstall(this);
 265
 266     EditorKit oldValue = editorKit;
 267     editorKit = newValue;
 268
 269     if (editorKit != null)
 270       {
 271         editorKit.install(this);
 272         setDocument(editorKit.createDefaultDocument());
 273       }
 274
 275     firePropertyChange("editorKit", oldValue, newValue);
 276     invalidate();
 277     repaint();
 278   }
 279
 280   public void setEditorKitForContentType(String type, EditorKit k)
 281   {
 282     // FIXME: editorKitCache.put(type, kit);
 283   }
 284
 285   /**
 286    * Sets the current URL being displayed.
 287    */
 288   public void setPage(String url) throws IOException
 289   {
 290     setPage(new URL(url));
 291   }
 292
 293   /**
 294    * Sets the current URL being displayed.
 295    */
 296   public void setPage(URL page) throws IOException
 297   {
 298     if (page == null)
 299       throw new IOException("invalid url");
 300
 301     try
 302       {
 303         this.page = page;
 304         getEditorKit().read(page.openStream(), getDocument(), 0);
 305       }
 306     catch (BadLocationException e)
 307       {
 308         // Ignored. '0' is always a valid offset.
 309       }
 310   }
 311
 312   public void setText(String t)
 313   {
 314     super.setText(t);
 315   }
 316
 317   /**
 318    * Add a <code>HyperlinkListener</code> object to this editor pane.
 319    *
 320    * @param listener the listener to add
 321    */
 322   public void addHyperlinkListener(HyperlinkListener listener)
 323   {
 324     listenerList.add(HyperlinkListener.class, listener);
 325   }
 326
 327   /**
 328    * Removes a <code>HyperlinkListener</code> object to this editor pane.
 329    *
 330    * @param listener the listener to remove
 331    */
 332   public void removeHyperlinkListener(HyperlinkListener listener)
 333   {
 334     listenerList.remove(HyperlinkListener.class, listener);
 335   }
 336
 337   /**
 338    * Returns all added <code>HyperlinkListener</code> objects.
 339    *
 340    * @return array of listeners
 341    *
 342    * @since 1.4
 343    */
 344   public HyperlinkListener[] getHyperlinkListeners()
 345   {
 346     return (HyperlinkListener[]) getListeners(HyperlinkListener.class);
 347   }
 348 }