libjava/javax/swing/text/AbstractDocument.java

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