libjava/javax/swing/text/AbstractDocument.java

   1 /* AbstractDocument.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.text;
  40
  41 import java.io.PrintStream;
  42 import java.io.Serializable;
  43 import java.util.Dictionary;
  44 import java.util.Enumeration;
  45 import java.util.EventListener;
  46 import java.util.Vector;
  47
  48 import javax.swing.event.DocumentEvent;
  49 import javax.swing.event.DocumentListener;
  50 import javax.swing.event.EventListenerList;
  51 import javax.swing.event.UndoableEditEvent;
  52 import javax.swing.event.UndoableEditListener;
  53 import javax.swing.tree.TreeNode;
  54 import javax.swing.undo.AbstractUndoableEdit;
  55 import javax.swing.undo.CompoundEdit;
  56 import javax.swing.undo.UndoableEdit;
  57
  58 public abstract class AbstractDocument
  59   implements Document, Serializable
  60 {
  61   private static final long serialVersionUID = -116069779446114664L;
  62
  63   protected static final String BAD_LOCATION = "document location failure";
  64
  65   public static final String BidiElementName = "bidi level";
  66   public static final String ContentElementName = "content";
  67   public static final String ParagraphElementName = "paragraph";
  68   public static final String SectionElementName = "section";
  69   public static final String ElementNameAttribute = "$ename";
  70
  71   Content content;
  72   AttributeContext context;
  73   DocumentFilter documentFilter;
  74
  75   protected EventListenerList listenerList = new EventListenerList();
  76
  77   protected AbstractDocument(Content doc)
  78   {
  79     this(doc, StyleContext.getDefaultStyleContext());
  80   }
  81
  82   protected AbstractDocument(Content doc, AttributeContext ctx)
  83   {
  84     content = doc;
  85     context = ctx;
  86   }
  87
  88   // These still need to be implemented by a derived class:
  89   public abstract Element getParagraphElement(int pos);
  90
  91   public abstract Element getDefaultRootElement();
  92
  93   protected Element createBranchElement(Element parent,
  94                                         AttributeSet attributes)
  95   {
  96     return new BranchElement(parent, attributes);
  97   }
  98
  99   protected Element createLeafElement(Element parent, AttributeSet attributes,
 100                                       int start, int end)
 101   {
 102     return new LeafElement(parent, attributes, start, end);
 103   }
 104
 105   public Position createPosition(final int offset) throws BadLocationException
 106   {
 107     if (offset < 0 || offset > getLength())
 108       throw new BadLocationException(getText(0, getLength()), offset);
 109
 110     return new Position()
 111       {
 112         public int getOffset()
 113         {
 114           return offset;
 115         }
 116       };
 117   }
 118
 119   protected void fireChangedUpdate(DocumentEvent event)
 120   {
 121     DocumentListener[] listeners = getDocumentListeners();
 122
 123     for (int index = 0; index < listeners.length; ++index)
 124       listeners[index].changedUpdate(event);
 125   }
 126
 127   protected void fireInsertUpdate(DocumentEvent event)
 128   {
 129     DocumentListener[] listeners = getDocumentListeners();
 130
 131     for (int index = 0; index < listeners.length; ++index)
 132       listeners[index].insertUpdate(event);
 133   }
 134
 135   protected void fireRemoveUpdate(DocumentEvent event)
 136   {
 137     DocumentListener[] listeners = getDocumentListeners();
 138
 139     for (int index = 0; index < listeners.length; ++index)
 140       listeners[index].removeUpdate(event);
 141   }
 142
 143   protected void fireUndoableEditUpdate(UndoableEditEvent event)
 144   {
 145     UndoableEditListener[] listeners = getUndoableEditListeners();
 146
 147     for (int index = 0; index < listeners.length; ++index)
 148       listeners[index].undoableEditHappened(event);
 149   }
 150
 151   public int getAsynchronousLoadPriority()
 152   {
 153     return 0;
 154   }
 155
 156   protected AttributeContext getAttributeContext()
 157   {
 158     return context;
 159   }
 160
 161   public Element getBidiRootElement()
 162   {
 163     return null;
 164   }
 165
 166   protected Content getContent()
 167   {
 168     return content;
 169   }
 170
 171   protected Thread getCurrentWriter()
 172   {
 173     return null;
 174   }
 175
 176   public Dictionary getDocumentProperties()
 177   {
 178     return null;
 179   }
 180
 181   public Position getEndPosition()
 182   {
 183     return new Position()
 184       {
 185         public int getOffset()
 186         {
 187           return getLength();
 188         }
 189       };
 190   }
 191
 192   public int getLength()
 193   {
 194     return content.length() - 1;
 195   }
 196
 197   public EventListener[] getListeners(Class listenerType)
 198   {
 199     return listenerList.getListeners(listenerType);
 200   }
 201
 202   public Object getProperty(Object key)
 203   {
 204     return null;
 205   }
 206
 207   public Element[] getRootElements()
 208   {
 209     Element[] elements = new Element[1];
 210     elements[0] = getDefaultRootElement();
 211     return elements;
 212   }
 213
 214   public Position getStartPosition()
 215   {
 216     return new Position()
 217       {
 218         public int getOffset()
 219         {
 220           return 0;
 221         }
 222       };
 223   }
 224
 225   public String getText(int offset, int length) throws BadLocationException
 226   {
 227     return content.getString(offset, length);
 228   }
 229
 230   public void getText(int offset, int length, Segment segment)
 231     throws BadLocationException
 232   {
 233     content.getChars(offset, length, segment);
 234   }
 235
 236   public void insertString(int offset, String text, AttributeSet attributes)
 237     throws BadLocationException
 238   {
 239     // Just return when no text to insert was given.
 240     if (text == null || text.length() == 0)
 241       return;
 242
 243     DefaultDocumentEvent event =
 244       new DefaultDocumentEvent(offset, text.length(),
 245                                DocumentEvent.EventType.INSERT);
 246     content.insertString(offset, text);
 247     insertUpdate(event, attributes);
 248     fireInsertUpdate(event);
 249   }
 250
 251   protected void insertUpdate(DefaultDocumentEvent chng, AttributeSet attr)
 252   {
 253   }
 254
 255   protected void postRemoveUpdate(DefaultDocumentEvent chng)
 256   {
 257   }
 258
 259   public void putProperty(Object key, Object value)
 260   {
 261   }
 262
 263   public void readLock()
 264   {
 265   }
 266
 267   public void readUnlock()
 268   {
 269   }
 270
 271   public void remove(int offset, int length) throws BadLocationException
 272   {
 273     DefaultDocumentEvent event =
 274       new DefaultDocumentEvent(offset, length,
 275                                DocumentEvent.EventType.REMOVE);
 276     removeUpdate(event);
 277     content.remove(offset, length);
 278     postRemoveUpdate(event);
 279     fireRemoveUpdate(event);
 280   }
 281
 282   /**
 283    * Replaces some text in the document.
 284    *
 285    * @since 1.4
 286    */
 287   public void replace(int offset, int length, String text,
 288                       AttributeSet attributes)
 289     throws BadLocationException
 290   {
 291     remove(offset, length);
 292     insertString(offset, text, attributes);
 293   }
 294
 295   /**
 296    * Adds a <code>DocumentListener</code> object to this document.
 297    *
 298    * @param listener the listener to add
 299    */
 300   public void addDocumentListener(DocumentListener listener)
 301   {
 302     listenerList.add(DocumentListener.class, listener);
 303   }
 304
 305   /**
 306    * Removes a <code>DocumentListener</code> object from this document.
 307    *
 308    * @param listener the listener to remove
 309    */
 310   public void removeDocumentListener(DocumentListener listener)
 311   {
 312     listenerList.remove(DocumentListener.class, listener);
 313   }
 314
 315   /**
 316    * Returns add added <code>DocumentListener</code> objects.
 317    *
 318    * @return an array of listeners
 319    */
 320   public DocumentListener[] getDocumentListeners()
 321   {
 322     return (DocumentListener[]) getListeners(DocumentListener.class);
 323   }
 324
 325   /**
 326    * Adds a <code>UndoableEditListener</code> object to this document.
 327    *
 328    * @param listener the listener to add
 329    */
 330   public void addUndoableEditListener(UndoableEditListener listener)
 331   {
 332     listenerList.add(UndoableEditListener.class, listener);
 333   }
 334
 335   /**
 336    * Removes a <code>UndoableEditListener</code> object from this document.
 337    *
 338    * @param listener the listener to remove
 339    */
 340   public void removeUndoableEditListener(UndoableEditListener listener)
 341   {
 342     listenerList.remove(UndoableEditListener.class, listener);
 343   }
 344
 345   /**
 346    * Returns add added <code>UndoableEditListener</code> objects.
 347    *
 348    * @return an array of listeners
 349    */
 350   public UndoableEditListener[] getUndoableEditListeners()
 351   {
 352     return (UndoableEditListener[]) getListeners(UndoableEditListener.class);
 353   }
 354
 355   protected void removeUpdate(DefaultDocumentEvent chng)
 356   {
 357   }
 358
 359   public void render(Runnable r)
 360   {
 361   }
 362
 363   public void setAsynchronousLoadPriority(int p)
 364   {
 365   }
 366
 367   public void setDocumentProperties(Dictionary x)
 368   {
 369   }
 370
 371   protected void writeLock()
 372   {
 373   }
 374
 375   protected void writeUnlock()
 376   {
 377   }
 378
 379   /**
 380    * @since 1.4
 381    */
 382   public DocumentFilter getDocumentFilter()
 383   {
 384     return documentFilter;
 385   }
 386
 387   /**
 388    * @since 1.4
 389    */
 390   public void setDocumentFilter(DocumentFilter filter)
 391   {
 392     this.documentFilter = filter;
 393   }
 394
 395   public void dump(PrintStream out)
 396   {
 397     ((AbstractElement) getDefaultRootElement()).dump(out, 0);
 398   }
 399
 400   public interface AttributeContext
 401   {
 402     AttributeSet addAttribute(AttributeSet old, Object name, Object value);
 403
 404     AttributeSet addAttributes(AttributeSet old, AttributeSet attributes);
 405
 406     AttributeSet getEmptySet();
 407
 408     void reclaim(AttributeSet attributes);
 409
 410     AttributeSet removeAttribute(AttributeSet old, Object name);
 411
 412     AttributeSet removeAttributes(AttributeSet old, AttributeSet attributes);
 413
 414     AttributeSet removeAttributes(AttributeSet old, Enumeration names);
 415   }
 416
 417   public interface Content
 418   {
 419     Position createPosition(int offset) throws BadLocationException;
 420
 421     int length();
 422
 423     UndoableEdit insertString(int where, String str)
 424       throws BadLocationException;
 425
 426     UndoableEdit remove(int where, int nitems) throws BadLocationException;
 427
 428     String getString(int where, int len) throws BadLocationException;
 429
 430     void getChars(int where, int len, Segment txt) throws BadLocationException;
 431   }
 432
 433   public abstract class AbstractElement
 434     implements Element, MutableAttributeSet, TreeNode, Serializable
 435   {
 436     private static final long serialVersionUID = 1265312733007397733L;
 437     int count;
 438     int offset;
 439
 440     AttributeSet attributes;
 441
 442     Element element_parent;
 443
 444     TreeNode tree_parent;
 445     Vector tree_children;
 446
 447     public AbstractElement(Element p, AttributeSet s)
 448     {
 449       element_parent = p;
 450       attributes = s;
 451     }
 452
 453     // TreeNode implementation
 454
 455     public abstract Enumeration children();
 456
 457     public abstract boolean getAllowsChildren();
 458
 459     public TreeNode getChildAt(int index)
 460     {
 461       return (TreeNode) tree_children.get(index);
 462     }
 463
 464     public int getChildCount()
 465     {
 466       return tree_children.size();
 467     }
 468
 469     public int getIndex(TreeNode node)
 470     {
 471       return tree_children.indexOf(node);
 472     }
 473
 474     public TreeNode getParent()
 475     {
 476       return tree_parent;
 477     }
 478
 479     public abstract boolean isLeaf();
 480
 481
 482     // MutableAttributeSet support
 483
 484     public void addAttribute(Object name, Object value)
 485     {
 486       attributes = getAttributeContext().addAttribute(attributes, name, value);
 487     }
 488
 489     public void addAttributes(AttributeSet attrs)
 490     {
 491       attributes = getAttributeContext().addAttributes(attributes, attrs);
 492     }
 493
 494     public void removeAttribute(Object name)
 495     {
 496       attributes = getAttributeContext().removeAttribute(attributes, name);
 497     }
 498
 499     public void removeAttributes(AttributeSet attrs)
 500     {
 501       attributes = getAttributeContext().removeAttributes(attributes, attrs);
 502     }
 503
 504     public void removeAttributes(Enumeration names)
 505     {
 506       attributes = getAttributeContext().removeAttributes(attributes, names);
 507     }
 508
 509     public void setResolveParent(AttributeSet parent)
 510     {
 511       attributes = getAttributeContext().addAttribute(attributes, ResolveAttribute, parent);
 512     }
 513
 514
 515     // AttributeSet interface support
 516
 517     public boolean containsAttribute(Object name, Object value)
 518     {
 519       return attributes.containsAttribute(name, value);
 520     }
 521
 522     public boolean containsAttributes(AttributeSet attrs)
 523     {
 524       return attributes.containsAttributes(attrs);
 525     }
 526
 527     public AttributeSet copyAttributes()
 528     {
 529       return attributes.copyAttributes();
 530     }
 531
 532     public Object getAttribute(Object key)
 533     {
 534       return attributes.getAttribute(key);
 535     }
 536
 537     public int getAttributeCount()
 538     {
 539       return attributes.getAttributeCount();
 540     }
 541
 542     public Enumeration getAttributeNames()
 543     {
 544       return attributes.getAttributeNames();
 545     }
 546
 547     public AttributeSet getResolveParent()
 548     {
 549       return attributes.getResolveParent();
 550     }
 551
 552     public boolean isDefined(Object attrName)
 553     {
 554       return attributes.isDefined(attrName);
 555     }
 556
 557     public boolean isEqual(AttributeSet attrs)
 558     {
 559       return attributes.isEqual(attrs);
 560     }
 561
 562     // Element interface support
 563
 564     public AttributeSet getAttributes()
 565     {
 566       return attributes;
 567     }
 568
 569     public Document getDocument()
 570     {
 571       return AbstractDocument.this;
 572     }
 573
 574     public abstract Element getElement(int index);
 575
 576     public String getName()
 577     {
 578       return (String) getAttribute(NameAttribute);
 579     }
 580
 581     public Element getParentElement()
 582     {
 583       return element_parent;
 584     }
 585
 586     public abstract int getEndOffset();
 587
 588     public abstract int getElementCount();
 589
 590     public abstract int getElementIndex(int offset);
 591
 592     public abstract int getStartOffset();
 593
 594     private void dumpElement(PrintStream stream, String indent, Element element)
 595     {
 596       System.out.println(indent + "<" + element.getName() +">");
 597
 598       if (element.isLeaf())
 599         {
 600           int start = element.getStartOffset();
 601           int end = element.getEndOffset();
 602           String text = "";
 603           try
 604             {
 605               text = getContent().getString(start, end - start);
 606             }
 607           catch (BadLocationException e)
 608             {
 609             }
 610           System.out.println(indent + "  ["
 611                              + start + ","
 612                              + end + "]["
 613                              + text + "]");
 614         }
 615       else
 616         {
 617           for (int i = 0; i < element.getElementCount(); ++i)
 618             dumpElement(stream, indent + "  ", element.getElement(i));
 619         }
 620     }
 621
 622     public void dump(PrintStream stream, int indent)
 623     {
 624       String indentStr = "";
 625       for (int i = 0; i < indent; ++i)
 626         indentStr += "  ";
 627       dumpElement(stream, indentStr, this);
 628     }
 629   }
 630
 631   public class BranchElement extends AbstractElement
 632   {
 633     private static final long serialVersionUID = -8595176318868717313L;
 634
 635     private Element[] children = new Element[0];
 636
 637     public BranchElement(Element parent, AttributeSet attributes)
 638     {
 639       super(parent, attributes);
 640     }
 641
 642     public Enumeration children()
 643     {
 644       if (children.length == 0)
 645         return null;
 646
 647       Vector tmp = new Vector();
 648
 649       for (int index = 0; index < children.length; ++index)
 650         tmp.add(children[index]);
 651
 652       return tmp.elements();
 653     }
 654
 655     public boolean getAllowsChildren()
 656     {
 657       return true;
 658     }
 659
 660     public Element getElement(int index)
 661     {
 662       if (index < 0 || index >= children.length)
 663         return null;
 664
 665       return children[index];
 666     }
 667
 668     public int getElementCount()
 669     {
 670       return children.length;
 671     }
 672
 673     public int getElementIndex(int offset)
 674     {
 675       // XXX: There is surely a better algorithm
 676       // as beginning from first element each time.
 677       for (int index = 0; index < children.length; ++index)
 678         {
 679           Element elem = children[index];
 680
 681           if ((elem.getStartOffset() <= offset)
 682               && (offset < elem.getEndOffset()))
 683             return index;
 684         }
 685
 686       return 0;
 687     }
 688
 689     public int getEndOffset()
 690     {
 691       return children[children.length - 1].getEndOffset();
 692     }
 693
 694     public String getName()
 695     {
 696       return ParagraphElementName;
 697     }
 698
 699     public int getStartOffset()
 700     {
 701       return children[0].getStartOffset();
 702     }
 703
 704     public boolean isLeaf()
 705     {
 706       return false;
 707     }
 708
 709     public Element positionToElement(int position)
 710     {
 711       // XXX: There is surely a better algorithm
 712       // as beginning from first element each time.
 713       for (int index = 0; index < children.length; ++index)
 714         {
 715           Element elem = children[index];
 716
 717           if ((elem.getStartOffset() <= position)
 718               && (position < elem.getEndOffset()))
 719             return elem;
 720         }
 721
 722       return null;
 723     }
 724
 725     public void replace(int offset, int length, Element[] elements)
 726     {
 727       Element[] target = new Element[children.length - length
 728                                      + elements.length];
 729       System.arraycopy(children, 0, target, 0, offset);
 730       System.arraycopy(elements, 0, target, offset, elements.length);
 731       System.arraycopy(children, offset + length, target,
 732                        offset + elements.length,
 733                        children.length - offset - length);
 734       children = target;
 735     }
 736
 737     public String toString()
 738     {
 739       return ("BranchElement(" + getName() + ") "
 740               + getStartOffset() + "," + getEndOffset() + "\n");
 741     }
 742   }
 743
 744   public class DefaultDocumentEvent extends CompoundEdit
 745     implements DocumentEvent
 746   {
 747     private static final long serialVersionUID = -7406103236022413522L;
 748
 749     private int offset;
 750     private int length;
 751     private DocumentEvent.EventType type;
 752
 753     public DefaultDocumentEvent(int offset, int length,
 754                                 DocumentEvent.EventType type)
 755     {
 756       this.offset = offset;
 757       this.length = length;
 758       this.type = type;
 759     }
 760
 761     public Document getDocument()
 762     {
 763       return AbstractDocument.this;
 764     }
 765
 766     public int getLength()
 767     {
 768       return length;
 769     }
 770
 771     public int getOffset()
 772     {
 773       return offset;
 774     }
 775
 776     public DocumentEvent.EventType getType()
 777     {
 778       return type;
 779     }
 780
 781     public DocumentEvent.ElementChange getChange(Element elem)
 782     {
 783       return null;
 784     }
 785   }
 786
 787   public static class ElementEdit extends AbstractUndoableEdit
 788     implements DocumentEvent.ElementChange
 789   {
 790     private static final long serialVersionUID = -1216620962142928304L;
 791
 792     private Element elem;
 793     private int index;
 794     private Element[] removed;
 795     private Element[] added;
 796
 797     public ElementEdit(Element elem, int index,
 798                        Element[] removed, Element[] added)
 799     {
 800       this.elem = elem;
 801       this.index = index;
 802       this.removed = removed;
 803       this.added = added;
 804     }
 805
 806     public Element[] getChildrenAdded()
 807     {
 808       return added;
 809     }
 810
 811     public Element[] getChildrenRemoved()
 812     {
 813       return removed;
 814     }
 815
 816     public Element getElement()
 817     {
 818       return elem;
 819     }
 820
 821     public int getIndex()
 822     {
 823       return index;
 824     }
 825   }
 826
 827   public class LeafElement extends AbstractElement
 828   {
 829     private static final long serialVersionUID = 5115368706941283802L;
 830     private int start;
 831     private int end;
 832
 833     public LeafElement(Element parent, AttributeSet attributes, int start,
 834                        int end)
 835     {
 836       super(parent, attributes);
 837       this.start = start;
 838       this.end = end;
 839     }
 840
 841     public Enumeration children()
 842     {
 843       return null;
 844     }
 845
 846     public boolean getAllowsChildren()
 847     {
 848       return false;
 849     }
 850
 851     public Element getElement(int index)
 852     {
 853       return null;
 854     }
 855
 856     public int getElementCount()
 857     {
 858       return 0;
 859     }
 860
 861     public int getElementIndex(int offset)
 862     {
 863       return -1;
 864     }
 865
 866     public int getEndOffset()
 867     {
 868       return end;
 869     }
 870
 871     public String getName()
 872     {
 873       return ContentElementName;
 874     }
 875
 876     public int getStartOffset()
 877     {
 878       return start;
 879     }
 880
 881     public boolean isLeaf()
 882     {
 883       return true;
 884     }
 885
 886     public String toString()
 887     {
 888       return ("LeafElement(" + getName() + ") "
 889               + getStartOffset() + "," + getEndOffset() + "\n");
 890     }
 891   }
 892 }