net.sourceforge.phpeclipse.ui/src/net/sourceforge/phpeclipse/ui/text/rules/AbstractPartitioner.java

   1 /*
   2  * Copyright (c) 2002-2004 Widespace, OU and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://solareclipse.sourceforge.net/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     Igor Malinin - initial contribution
  10  *
  11  * $Id: AbstractPartitioner.java,v 1.3 2004-12-29 21:42:31 axelcl Exp $
  12  */
  13
  14 package net.sourceforge.phpeclipse.ui.text.rules;
  15
  16 import java.util.ArrayList;
  17 import java.util.List;
  18
  19 import org.eclipse.jface.text.Assert;
  20 import org.eclipse.jface.text.DocumentEvent;
  21 import org.eclipse.jface.text.IDocument;
  22 import org.eclipse.jface.text.IDocumentPartitioner;
  23 import org.eclipse.jface.text.IDocumentPartitionerExtension;
  24 import org.eclipse.jface.text.IRegion;
  25 import org.eclipse.jface.text.ITypedRegion;
  26 import org.eclipse.jface.text.Region;
  27 import org.eclipse.jface.text.TypedRegion;
  28 import org.eclipse.jface.text.rules.IPartitionTokenScanner;
  29 import org.eclipse.jface.text.rules.IToken;
  30
  31 /**
  32  * Advanced partitioner which maintains partitions as views to connected document. Views have own partitioners themselves. This
  33  * class is designed as a base for complex partitioners such as for JSP, PHP, ASP, etc. languages.
  34  *
  35  * @author Igor Malinin
  36  */
  37 public abstract class AbstractPartitioner implements IDocumentPartitioner, IDocumentPartitionerExtension {
  38   public final static boolean DEBUG = false;
  39
  40   /** Partition scanner */
  41   protected IPartitionTokenScanner scanner;
  42
  43   /** Connected document */
  44   protected IDocument document;
  45
  46   /** Flat structure of the document */
  47   protected List nodes = new ArrayList();
  48
  49   /** The offset at which the first changed partition starts */
  50   protected int regionStart;
  51
  52   /** The offset at which the last changed partition ends */
  53   protected int regionEnd;
  54
  55   public AbstractPartitioner(IPartitionTokenScanner scanner) {
  56     this.scanner = scanner;
  57   }
  58
  59   protected FlatNode createNode(String type, int offset, int length) {
  60     if (DEBUG) {
  61       Assert.isTrue(offset >= 0, Integer.toString(offset));
  62     }
  63     FlatNode node = new FlatNode(type);
  64     node.offset = offset;
  65     node.length = length;
  66     return node;
  67   }
  68
  69   protected void addInnerRegion(FlatNode position) {
  70     nodes.add(computeFlatNodeIndex(position.offset), position);
  71   }
  72
  73   protected void removeInnerRegion(FlatNode position) {
  74     nodes.remove(position); // TODO: Indexed remove?
  75   }
  76
  77   protected void deleteInnerRegion(FlatNode position) {
  78     nodes.remove(position); // TODO: Indexed remove?
  79   }
  80
  81   protected void resizeInnerRegion(FlatNode position) {
  82   }
  83
  84   /*
  85    * @see org.eclipse.jface.text.IDocumentPartitioner#connect(IDocument)
  86    */
  87   public void connect(IDocument document) {
  88     this.document = document;
  89
  90     initialize();
  91   }
  92
  93   /*
  94    * @see org.eclipse.jface.text.IDocumentPartitioner#disconnect()
  95    */
  96   public void disconnect() {
  97     nodes.clear();
  98     document = null;
  99   }
 100
 101   /**
 102    * Performs the initial partitioning of the partitioner's document.
 103    */
 104   protected void initialize() {
 105     scanner.setRange(document, 0, document.getLength());
 106     // axelcl start
 107     nodes.clear();
 108     // axelcl end
 109     IToken token = scanner.nextToken();
 110     while (!token.isEOF()) {
 111       String contentType = getTokenContentType(token);
 112
 113       if (isSupportedContentType(contentType)) {
 114         addInnerRegion(createNode(contentType, scanner.getTokenOffset(), scanner.getTokenLength()));
 115       }
 116
 117       token = scanner.nextToken();
 118     }
 119   }
 120
 121   /*
 122    * @see org.eclipse.jface.text.IDocumentPartitioner#documentAboutToBeChanged(DocumentEvent)
 123    */
 124   public void documentAboutToBeChanged(DocumentEvent event) {
 125     regionStart = regionEnd = -1;
 126   }
 127
 128   /*
 129    * @see org.eclipse.jface.text.IDocumentPartitioner#documentChanged(DocumentEvent)
 130    */
 131   public boolean documentChanged(DocumentEvent event) {
 132     return (documentChanged2(event) != null);
 133   }
 134
 135   /*
 136    * @see org.eclipse.jface.text.IDocumentPartitionerExtension#documentChanged2(DocumentEvent)
 137    */
 138   public IRegion documentChanged2(DocumentEvent event) {
 139     int first = fixupPartitions(event);
 140
 141     FlatNode[] category = (FlatNode[]) nodes.toArray(new FlatNode[nodes.size()]);
 142
 143     // repartition changed region
 144
 145     String contentType = IDocument.DEFAULT_CONTENT_TYPE;
 146
 147     int offset;
 148
 149     if (first == 0) {
 150       offset = 0; // Bug #697414: first offset
 151     } else {
 152       offset = event.getOffset();
 153
 154       FlatNode partition = category[first - 1];
 155       if (partition.includes(offset)) {
 156         offset = partition.offset;
 157         contentType = partition.type;
 158         --first;
 159       } else if (offset == partition.offset + partition.length) {
 160         offset = partition.offset;
 161         contentType = partition.type;
 162         --first;
 163       } else {
 164         offset = partition.offset + partition.length;
 165       }
 166     }
 167
 168     // should not be changed since last conversion
 169     // category = (FlatNode[]) nodes.toArray(new FlatNode[nodes.size()]);
 170     if (DEBUG) {
 171       Assert.isTrue(offset >= 0, Integer.toString(offset));
 172     }
 173     scanner.setPartialRange(document, offset, document.getLength(), contentType, offset);
 174
 175     int lastScannedPosition = offset;
 176     IToken token = scanner.nextToken();
 177     while (!token.isEOF()) {
 178       contentType = getTokenContentType(token);
 179
 180       if (!isSupportedContentType(contentType)) {
 181         token = scanner.nextToken();
 182         continue;
 183       }
 184
 185       offset = scanner.getTokenOffset();
 186       if (DEBUG) {
 187         Assert.isTrue(offset >= 0, scanner.toString());
 188       }
 189       int length = scanner.getTokenLength();
 190
 191       lastScannedPosition = offset + length;
 192
 193       // remove all affected positions
 194       while (first < category.length) {
 195         FlatNode p = category[first];
 196         if (p.offset + p.length < lastScannedPosition
 197             || (p.overlapsWith(offset, length) && (!containsPosition(offset, length) || !contentType.equals(p.type)))) {
 198           removeInnerRegion(p);
 199           rememberRegion(p.offset, p.length);
 200           ++first;
 201         } else {
 202           break;
 203         }
 204       }
 205
 206       // if position already exists we are done
 207       if (containsPosition(offset, length)) {
 208         if (lastScannedPosition > event.getOffset()) {
 209           // TODO: optional repartition till end of doc
 210           return createRegion();
 211         }
 212
 213         ++first;
 214       } else {
 215         // insert the new type position
 216         addInnerRegion(createNode(contentType, offset, length));
 217         rememberRegion(offset, length);
 218       }
 219       //            try {
 220       token = scanner.nextToken();
 221       //            } catch (ArrayIndexOutOfBoundsException e) {
 222       //              System.out.println(this.getClass().toString());
 223       //              throw e;
 224       //            }
 225     }
 226
 227     // remove all positions behind lastScannedPosition
 228     // since there aren't any further types
 229
 230     // Do not need to recalculate (lost remove events)!
 231     // first = computeIndexInInnerDocuments(lastScannedPosition);
 232     while (first < category.length) {
 233       FlatNode p = category[first++];
 234       removeInnerRegion(p);
 235       rememberRegion(p.offset, p.length);
 236     }
 237
 238     return createRegion();
 239   }
 240
 241   protected int fixupPartitions(DocumentEvent event) {
 242     int offset = event.getOffset();
 243     int length = event.getLength();
 244     int end = offset + length;
 245
 246     // fixup flat nodes laying on change boundaries
 247
 248     int first = computeFlatNodeIndex(offset);
 249     if (first > 0) {
 250       FlatNode p = (FlatNode) nodes.get(first - 1);
 251
 252       int right = p.offset + p.length;
 253       if (offset < right) {
 254         // change overlaps with partition
 255         if (end < right) {
 256           // cahnge completely inside partition
 257           String text = event.getText();
 258           p.length -= length;
 259           if (text != null) {
 260             p.length += text.length();
 261           }
 262         } else {
 263           // cut partition at right
 264           int cut = p.offset + p.length - offset;
 265           p.length -= cut;
 266         }
 267       }
 268     }
 269
 270     int last = computeFlatNodeIndex(end);
 271     if (first < last) {
 272       FlatNode p = (FlatNode) nodes.get(last - 1);
 273
 274       int right = p.offset + p.length;
 275       if (end < right) {
 276         // cut partition at left
 277         int cut = end - p.offset;
 278         p.length -= cut;
 279         p.offset = offset;
 280
 281         String text = event.getText();
 282         if (text != null) {
 283           p.offset += text.length();
 284         }
 285
 286         --last;
 287       }
 288     }
 289
 290     // fixup flat nodes laying afrer change
 291
 292     String text = event.getText();
 293     if (text != null) {
 294       length -= text.length();
 295     }
 296
 297     for (int i = last, size = nodes.size(); i < size; i++) {
 298       ((FlatNode) nodes.get(i)).offset -= length;
 299     }
 300
 301     // delete flat nodes laying completely inside change boundaries
 302
 303     if (first < last) {
 304       do {
 305         deleteInnerRegion((FlatNode) nodes.get(--last));
 306       } while (first < last);
 307
 308       rememberRegion(offset, 0);
 309     }
 310
 311     return first;
 312   }
 313
 314   /**
 315    * Returns whether the given type is one of the legal content types.
 316    *
 317    * @param contentType
 318    *          the content type to check
 319    * @return <code>true</code> if the content type is a legal content type
 320    */
 321   protected boolean isSupportedContentType(String contentType) {
 322     /* TODO: implementation */
 323     //          if (contentType != null) {
 324     //                  for (int i= 0; i < fLegalContentTypes.length; i++) {
 325     //                          if (fLegalContentTypes[i].equals(contentType)) {
 326     //                                  return true;
 327     //                          }
 328     //                  }
 329     //          }
 330     //          return false;
 331     return (contentType != null);
 332   }
 333
 334   /**
 335    * Returns a content type encoded in the given token. If the token's data is not <code>null</code> and a string it is assumed
 336    * that it is the encoded content type.
 337    *
 338    * @param token
 339    *          the token whose content type is to be determined
 340    * @return the token's content type
 341    */
 342   protected String getTokenContentType(IToken token) {
 343     Object data = token.getData();
 344     if (data instanceof String) {
 345       return (String) data;
 346     }
 347
 348     return null;
 349   }
 350
 351   /*
 352    * @see org.eclipse.jface.text.IDocumentPartitioner#getLegalContentTypes()
 353    */
 354   public String[] getLegalContentTypes() {
 355     // TODO: implementation
 356     return null;
 357   }
 358
 359   /*
 360    * @see org.eclipse.jface.text.IDocumentPartitioner#getContentType(int)
 361    */
 362   public String getContentType(int offset) {
 363     return getPartition(offset).getType();
 364   }
 365
 366   /*
 367    * @see org.eclipse.jface.text.IDocumentPartitioner#getPartition(int)
 368    */
 369   public ITypedRegion getPartition(int offset) {
 370     if (nodes.size() == 0) {
 371       return new TypedRegion(0, document.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
 372     }
 373
 374     int index = computeFlatNodeIndex(offset);
 375     if (index < nodes.size()) {
 376       FlatNode next = (FlatNode) nodes.get(index);
 377
 378       if (offset == next.offset) {
 379         return new TypedRegion(next.offset, next.length, next.type);
 380       }
 381
 382       if (index == 0) {
 383         return new TypedRegion(0, next.offset, IDocument.DEFAULT_CONTENT_TYPE);
 384       }
 385
 386       FlatNode prev = (FlatNode) nodes.get(index - 1);
 387
 388       if (prev.includes(offset)) {
 389         return new TypedRegion(prev.offset, prev.length, prev.type);
 390       }
 391
 392       int end = prev.offset + prev.length;
 393       return new TypedRegion(end, next.offset - end, IDocument.DEFAULT_CONTENT_TYPE);
 394     }
 395
 396     FlatNode prev = (FlatNode) nodes.get(nodes.size() - 1);
 397
 398     if (prev.includes(offset)) {
 399       return new TypedRegion(prev.offset, prev.length, prev.type);
 400     }
 401
 402     int end = prev.offset + prev.length;
 403
 404     return new TypedRegion(end, document.getLength() - end, IDocument.DEFAULT_CONTENT_TYPE);
 405   }
 406
 407   /*
 408    * @see org.eclipse.jface.text.IDocumentPartitioner#computePartitioning(int, int)
 409    */
 410   public ITypedRegion[] computePartitioning(int offset, int length) {
 411     List list = new ArrayList();
 412
 413     int end = offset + length;
 414
 415     int index = computeFlatNodeIndex(offset);
 416     while (true) {
 417       FlatNode prev = (index > 0) ? (FlatNode) nodes.get(index - 1) : null;
 418
 419       if (prev != null) {
 420         if (prev.overlapsWith(offset, length)) {
 421           list.add(new TypedRegion(prev.offset, prev.length, prev.type));
 422         }
 423
 424         if (end <= prev.offset + prev.length) {
 425           break;
 426         }
 427       }
 428
 429       FlatNode next = (index < nodes.size()) ? (FlatNode) nodes.get(index) : null;
 430
 431       if (next == null || offset < next.offset) {
 432         int off0 = offset;
 433         int off1 = offset + length;
 434
 435         if (prev != null && off0 < prev.offset + prev.length) {
 436           off0 = prev.offset + prev.length;
 437         }
 438
 439         if (next != null && next.offset < off1) {
 440           off1 = next.offset;
 441         }
 442
 443         if (off0 < off1) {
 444           list.add(new TypedRegion(off0, off1 - off0, IDocument.DEFAULT_CONTENT_TYPE));
 445         }
 446       }
 447
 448       if (next == null) {
 449         break;
 450       }
 451
 452       ++index;
 453     }
 454
 455     return (TypedRegion[]) list.toArray(new TypedRegion[list.size()]);
 456   }
 457
 458   /**
 459    * Computes the index in the list of flat nodes at which an flat node with the given offset would be inserted. The flat node is
 460    * supposed to become the first in this list of all flat nodes with the same offset.
 461    *
 462    * @param offset
 463    *          the offset for which the index is computed
 464    * @return the computed index
 465    */
 466   protected int computeFlatNodeIndex(int offset) {
 467     if (nodes.size() == 0) {
 468       return 0;
 469     }
 470
 471     int left = 0, mid = 0;
 472     int right = nodes.size() - 1;
 473
 474     FlatNode p = null;
 475
 476     while (left < right) {
 477       mid = (left + right) / 2;
 478
 479       p = (FlatNode) nodes.get(mid);
 480
 481       if (offset < p.offset) {
 482         right = (left == mid) ? left : mid - 1;
 483       } else if (offset > p.offset) {
 484         left = (right == mid) ? right : mid + 1;
 485       } else if (offset == p.offset) {
 486         left = right = mid;
 487       }
 488     }
 489
 490     int pos = left;
 491     p = (FlatNode) nodes.get(pos);
 492     if (offset > p.offset) {
 493       // append to the end
 494       pos++;
 495     } else {
 496       // entry will became the first of all entries with the same offset
 497       do {
 498         --pos;
 499         if (pos < 0) {
 500           break;
 501         }
 502         p = (FlatNode) nodes.get(pos);
 503       } while (offset == p.offset);
 504       ++pos;
 505     }
 506
 507     return pos;
 508   }
 509
 510   public boolean containsPosition(int offset, int length) {
 511     int size = nodes.size();
 512     if (size == 0) {
 513       return false;
 514     }
 515
 516     int index = computeFlatNodeIndex(offset);
 517     if (index < size) {
 518       FlatNode p = (FlatNode) nodes.get(index);
 519
 520       while (p.offset == offset) {
 521         if (p.length == length) {
 522           return true;
 523         }
 524
 525         if (++index < size) {
 526           p = (FlatNode) nodes.get(index);
 527         } else {
 528           break;
 529         }
 530       }
 531     }
 532
 533     return false;
 534   }
 535
 536   /**
 537    * Helper method for tracking the minimal region containg all partition changes. If <code>offset</code> is smaller than the
 538    * remembered offset, <code>offset</code> will from now on be remembered. If <code>offset + length</code> is greater than the
 539    * remembered end offset, it will be remembered from now on.
 540    *
 541    * @param offset
 542    *          the offset
 543    * @param length
 544    *          the length
 545    */
 546   protected final void rememberRegion(int offset, int length) {
 547     // remember start offset
 548     if (regionStart == -1) {
 549       regionStart = offset;
 550     } else if (offset < regionStart) {
 551       regionStart = offset;
 552     }
 553
 554     // remember end offset
 555     int endOffset = offset + length;
 556
 557     if (regionEnd == -1) {
 558       regionEnd = endOffset;
 559     } else if (endOffset > regionEnd) {
 560       regionEnd = endOffset;
 561     }
 562   }
 563
 564   /**
 565    * Creates the minimal region containing all partition changes using the remembered offsets.
 566    *
 567    * @return the minimal region containing all the partition changes
 568    */
 569   protected final IRegion createRegion() {
 570     if (regionStart == -1 || regionEnd == -1) {
 571       return null;
 572     }
 573
 574     return new Region(regionStart, regionEnd - regionStart);
 575   }
 576 }