net.sourceforge.phpeclipse.ui/src/net/sourceforge/phpeclipse/ui/text/rules/MultiViewPartitioner.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: MultiViewPartitioner.java,v 1.9 2005-05-13 20:17: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.BadLocationException;
  21 import org.eclipse.jface.text.DocumentEvent;
  22 import org.eclipse.jface.text.IDocument;
  23 import org.eclipse.jface.text.IDocumentPartitioner;
  24 import org.eclipse.jface.text.IDocumentPartitioningListener;
  25 import org.eclipse.jface.text.IDocumentPartitioningListenerExtension;
  26 import org.eclipse.jface.text.IRegion;
  27 import org.eclipse.jface.text.ITypedRegion;
  28 import org.eclipse.jface.text.TypedRegion;
  29 import org.eclipse.jface.text.rules.IPartitionTokenScanner;
  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 MultiViewPartitioner extends AbstractPartitioner {
  38
  39   class ViewListener implements IDocumentPartitioningListener, IDocumentPartitioningListenerExtension {
  40
  41     /*
  42      * @see org.eclipse.jface.text.IDocumentPartitioningListener#documentPartitioningChanged(IDocument)
  43      */
  44     public void documentPartitioningChanged(IDocument document) {
  45       IDocumentView view = (IDocumentView) document;
  46
  47       int start = view.getParentOffset(0);
  48       int end = view.getParentOffset(view.getLength());
  49
  50       rememberRegion(start, end - start);
  51     }
  52
  53     /*
  54      * @see org.eclipse.jface.text.IDocumentPartitioningListenerExtension#documentPartitioningChanged(IDocument, IRegion)
  55      */
  56     public void documentPartitioningChanged(IDocument document, IRegion region) {
  57       IDocumentView view = (IDocumentView) document;
  58
  59       int offset = region.getOffset();
  60
  61       int start = view.getParentOffset(offset);
  62       int end = view.getParentOffset(offset + region.getLength());
  63
  64       rememberRegion(start, end - start);
  65     }
  66   }
  67
  68   private ViewListener viewListener = new ViewListener();
  69
  70   private OuterDocumentView outerDocument;
  71
  72   private DocumentEvent outerDocumentEvent;
  73
  74   public MultiViewPartitioner(IPartitionTokenScanner scanner) {
  75     super(scanner);
  76   }
  77
  78   public void setOuterPartitioner(IDocumentPartitioner partitioner) {
  79     if (outerDocument == null) {
  80       if (partitioner == null) {
  81         return;
  82       }
  83
  84       outerDocument = new OuterDocumentView(document, nodes);
  85       outerDocument.addDocumentPartitioningListener(viewListener);
  86     }
  87
  88     IDocumentPartitioner old = outerDocument.getDocumentPartitioner();
  89     if (old != null) {
  90       outerDocument.setDocumentPartitioner(null);
  91       old.disconnect();
  92     }
  93
  94     if (partitioner != null) {
  95       partitioner.connect(outerDocument);
  96     }
  97
  98     outerDocument.setDocumentPartitioner(partitioner);
  99
 100     if (partitioner == null) {
 101       outerDocument.removeDocumentPartitioningListener(viewListener);
 102       outerDocument = null;
 103     }
 104   }
 105
 106   /**
 107    * Create subpartitioner.
 108    *
 109    * @param contentType
 110    *          name of inner partition or <code>null</code> for outer partition
 111    */
 112   protected abstract IDocumentPartitioner createPartitioner(String contentType);
 113
 114   protected void addInnerRegion(FlatNode position) {
 115     if (outerDocument != null) {
 116       if (DEBUG) {
 117         Assert.isTrue(position.offset >= 0, Integer.toString(position.offset));
 118       }
 119       int outerOffset = outerDocument.getLocalOffset(position.offset);
 120       // axelcl start
 121       DocumentEvent event = null;
 122       if (outerOffset >= 0) {
 123         // axelcl end
 124         event = new DocumentEvent(outerDocument, outerOffset, position.length, null);
 125
 126         outerDocument.fireDocumentAboutToBeChanged(event);
 127       }
 128       super.addInnerRegion(position);
 129       //    axelcl start
 130       if (event != null) {
 131         // axelcl end
 132         outerDocument.fireDocumentChanged(event);
 133       }
 134     } else {
 135       super.addInnerRegion(position);
 136     }
 137
 138     if (position instanceof ViewNode) {
 139       // TODO: revisit condition
 140       IDocumentPartitioner partitioner = createPartitioner(position.type);
 141       if (partitioner != null) {
 142         InnerDocumentView innerDocument = new InnerDocumentView(document, (ViewNode) position);
 143
 144         ((ViewNode) position).view = innerDocument;
 145
 146         partitioner.connect(innerDocument);
 147         innerDocument.setDocumentPartitioner(partitioner);
 148         innerDocument.addDocumentPartitioningListener(viewListener);
 149       }
 150     }
 151   }
 152
 153   protected void removeInnerRegion(FlatNode position) {
 154     try {
 155       if (outerDocument != null) {
 156         DocumentEvent event = null;
 157         if (position.offset >= 0 && position.length >= 0) {
 158           int outerOffset = outerDocument.getLocalOffset(position.offset);
 159           if (outerOffset > 0) {
 160             event = new DocumentEvent(outerDocument, outerOffset, 0, document.get(position.offset, position.length));
 161
 162             outerDocument.fireDocumentAboutToBeChanged(event);
 163           }
 164         }
 165         super.removeInnerRegion(position);
 166         if (position.offset >= 0) {
 167           if (event != null) {
 168             outerDocument.fireDocumentChanged(event);
 169           }
 170         }
 171       } else {
 172         super.removeInnerRegion(position);
 173       }
 174
 175       if (position instanceof ViewNode) {
 176         // TODO: revisit condition
 177         InnerDocumentView innerDocument = ((ViewNode) position).view;
 178         if (innerDocument != null) {
 179           IDocumentPartitioner partitioner = innerDocument.getDocumentPartitioner();
 180
 181           innerDocument.removeDocumentPartitioningListener(viewListener);
 182           innerDocument.setDocumentPartitioner(null);
 183           partitioner.disconnect();
 184         }
 185       }
 186     } catch (BadLocationException e) {
 187     }
 188   }
 189
 190   protected void deleteInnerRegion(FlatNode position) {
 191     super.deleteInnerRegion(position);
 192
 193     if (position instanceof ViewNode) {
 194       // TODO: revisit condition
 195       InnerDocumentView innerDocument = ((ViewNode) position).view;
 196       if (innerDocument != null) {
 197         IDocumentPartitioner partitioner = innerDocument.getDocumentPartitioner();
 198
 199         innerDocument.removeDocumentPartitioningListener(viewListener);
 200         innerDocument.setDocumentPartitioner(null);
 201         partitioner.disconnect();
 202       }
 203     }
 204   }
 205
 206   public void connect(IDocument document) {
 207     //          outerDocument = new OuterDocumentView(document, innerPositions);
 208
 209     super.connect(document);
 210
 211     setOuterPartitioner(createPartitioner(null));
 212     //          IDocumentPartitioner partitioner =
 213     //                  partitioner.connect(outerDocument);
 214     //          outerDocument.setDocumentPartitioner(partitioner);
 215     //          outerDocument.addDocumentPartitioningListener(viewListener);
 216   }
 217
 218   public void disconnect() {
 219     try {
 220       if (outerDocument != null) {
 221         outerDocument.removeDocumentPartitioningListener(viewListener);
 222
 223         IDocumentPartitioner partitioner = outerDocument.getDocumentPartitioner();
 224
 225         outerDocument.setDocumentPartitioner(null);
 226         partitioner.disconnect();
 227       }
 228     } finally {
 229       // TODO: cleanup listeners
 230       outerDocument = null;
 231     }
 232   }
 233
 234   /*
 235    * @see org.eclipse.jface.text.IDocumentPartitioner#documentAboutToBeChanged(DocumentEvent)
 236    */
 237   public void documentAboutToBeChanged(DocumentEvent event) {
 238     super.documentAboutToBeChanged(event);
 239
 240     outerDocumentEvent = null;
 241
 242     int offset = event.getOffset();
 243     int length = event.getLength();
 244     int end = offset + length;
 245
 246     // find left partition
 247     int first = computeFlatNodeIndex(offset);
 248     if (first > 0) {
 249       FlatNode p = (FlatNode) nodes.get(first - 1);
 250
 251       int right = p.offset + p.length;
 252       if (offset < right) {
 253         // change overlaps with partition
 254         InnerDocumentView innerDocument = null;
 255         if (p instanceof ViewNode) {
 256           // TODO: revisit condition
 257           innerDocument = ((ViewNode) p).view;
 258         }
 259
 260         if (end < right) {
 261           if (innerDocument != null) {
 262             // cahnge completely inside partition
 263             int start = innerDocument.getLocalOffset(offset);
 264             innerDocument.fireDocumentAboutToBeChanged(new DocumentEvent(innerDocument, start, length, event.getText()));
 265           }
 266
 267           return;
 268         }
 269
 270         if (innerDocument != null) {
 271           // cut partition at right
 272           int start = innerDocument.getLocalOffset(offset);
 273           innerDocument.fireDocumentAboutToBeChanged(new DocumentEvent(innerDocument, start, innerDocument.getLength() - start,
 274               null));
 275         }
 276       }
 277     }
 278
 279     // find right partition
 280     int last = computeFlatNodeIndex(end);
 281     if (last > 0) {
 282       FlatNode p = (FlatNode) nodes.get(last - 1);
 283
 284       if (p instanceof ViewNode) {
 285         // TODO: revisit condition
 286         InnerDocumentView innerDocument = ((ViewNode) p).view;
 287         if (innerDocument != null) {
 288           int right = p.offset + p.length;
 289           if (end < right) {
 290             // cut partition at left
 291             int cut = innerDocument.getLocalOffset(end);
 292             innerDocument.fireDocumentAboutToBeChanged(new DocumentEvent(innerDocument, 0, cut, null));
 293           }
 294         }
 295       }
 296     }
 297
 298     if (outerDocument != null) {
 299       int left = outerDocument.getLocalOffset(offset);
 300       int right = outerDocument.getLocalOffset(end);
 301
 302       String text = event.getText();
 303
 304       if (left >= 0 && (right - left >= 0)) {
 305         if (left != right || text != null && text.length() > 0) {
 306           outerDocumentEvent = new DocumentEvent(outerDocument, left, right - left, text);
 307
 308           outerDocument.fireDocumentAboutToBeChanged(outerDocumentEvent);
 309         }
 310       }
 311     }
 312   }
 313
 314   protected int fixupPartitions(DocumentEvent event) {
 315     int offset = event.getOffset();
 316     int length = event.getLength();
 317     int end = offset + length;
 318
 319     // fixup/notify inner views laying on change boundaries
 320
 321     int first = computeFlatNodeIndex(offset);
 322     if (first > 0) {
 323       FlatNode p = (FlatNode) nodes.get(first - 1);
 324
 325       int right = p.offset + p.length;
 326       if (offset < right) {
 327         // change overlaps with partition
 328         if (end < right) {
 329           // cahnge completely inside partition
 330           String text = event.getText();
 331           p.length -= length;
 332           if (text != null) {
 333             p.length += text.length();
 334           }
 335
 336           if (p instanceof ViewNode) {
 337             // TODO: revisit condition
 338             InnerDocumentView innerDocument = ((ViewNode) p).view;
 339             if (innerDocument != null) {
 340               int start = innerDocument.getLocalOffset(offset);
 341               innerDocument.fireDocumentChanged(new DocumentEvent(innerDocument, start, length, text));
 342             }
 343           }
 344         } else {
 345           // cut partition at right
 346           int cut = p.offset + p.length - offset;
 347           p.length -= cut;
 348
 349           if (p instanceof ViewNode) {
 350             // TODO: revisit condition
 351             InnerDocumentView innerDocument = ((ViewNode) p).view;
 352             if (innerDocument != null) {
 353               int start = innerDocument.getLocalOffset(offset);
 354               // TODO: ???fireDocumentAboutToBeChanged???
 355               innerDocument.fireDocumentChanged(new DocumentEvent(innerDocument, start, cut, null));
 356             }
 357           }
 358         }
 359       }
 360     }
 361
 362     int last = computeFlatNodeIndex(end);
 363     if (last > 0 && first != last) {
 364       FlatNode p = (FlatNode) nodes.get(last - 1);
 365
 366       int right = p.offset + p.length;
 367       if (end < right) {
 368         // cut partition at left
 369         int cut = end - p.offset;
 370         p.length -= cut;
 371         p.offset = offset;
 372
 373         String text = event.getText();
 374         if (text != null) {
 375           p.offset += text.length();
 376         }
 377
 378         if (p instanceof ViewNode) {
 379           // TODO: revisit condition
 380           InnerDocumentView innerDocument = ((ViewNode) p).view;
 381           if (innerDocument != null) {
 382             // TODO: ???fireDocumentAboutToBeChanged???
 383             innerDocument.fireDocumentChanged(new DocumentEvent(innerDocument, 0, cut, null));
 384           }
 385         }
 386
 387         --last;
 388       }
 389     }
 390
 391     // fixup inner views laying afrer change
 392
 393     String text = event.getText();
 394     if (text != null) {
 395       length -= text.length();
 396     }
 397
 398     for (int i = last, size = nodes.size(); i < size; i++) {
 399       ((FlatNode) nodes.get(i)).offset -= length;
 400     }
 401
 402     // delete inner views laying completely inside change boundaries
 403
 404     if (first < last) {
 405       do {
 406         deleteInnerRegion((FlatNode) nodes.get(--last));
 407       } while (first < last);
 408
 409       rememberRegion(offset, 0);
 410     }
 411
 412     // notify outer view
 413
 414     if (outerDocumentEvent != null) {
 415       outerDocument.fireDocumentChanged(outerDocumentEvent);
 416     }
 417
 418     return first;
 419   }
 420
 421   /*
 422    * @see org.eclipse.jface.text.IDocumentPartitioner#computePartitioning(int, int)
 423    */
 424   protected String getContentType(String parent, String view) {
 425     if (view != null) {
 426       return view;
 427     }
 428
 429     if (parent != null) {
 430       return parent;
 431     }
 432
 433     return IDocument.DEFAULT_CONTENT_TYPE;
 434   }
 435
 436   /*
 437    * @see org.eclipse.jface.text.IDocumentPartitioner#computePartitioning(int, int)
 438    */
 439   public ITypedRegion[] computePartitioning(int offset, int length) {
 440     List list = new ArrayList();
 441 //        if (DEBUG) {
 442 //          if (length>=9400) {
 443 //            length--;
 444 //          }
 445 //          System.out.print("MultiViewPartitioner::computePartitioning - Offset: ");
 446 //          System.out.print(offset);
 447 //          System.out.print(", Length: ");
 448 //          System.out.print(length);
 449 //          System.out.println("");
 450 //        }
 451     int end = offset + length;
 452
 453     int index = computeFlatNodeIndex(offset);
 454     while (true) {
 455       FlatNode prev = (index > 0) ? (FlatNode) nodes.get(index - 1) : null;
 456
 457       if (prev != null) {
 458         if (prev.overlapsWith(offset, length)) {
 459           addInnerPartitions(list, offset, length, prev);
 460         }
 461
 462         if (end <= prev.offset + prev.length) {
 463           break;
 464         }
 465       }
 466
 467       FlatNode next = (index < nodes.size()) ? (FlatNode) nodes.get(index) : null;
 468
 469       if (next == null || offset < next.offset) {
 470         addOuterPartitions(list, offset, length, prev, next);
 471       }
 472
 473       if (next == null) {
 474         break;
 475       }
 476
 477       ++index;
 478     }
 479     //    if (DEBUG) {
 480     //      showList(list);
 481     //    }
 482
 483     return (TypedRegion[]) list.toArray(new TypedRegion[list.size()]);
 484   }
 485
 486   private void showList(List list) {
 487     try {
 488       throw new NullPointerException();
 489     } catch (Exception e) {
 490       e.printStackTrace();
 491     }
 492     System.out.println(">>>>>List start");
 493     TypedRegion temp;
 494     for (int i = 0; i < list.size(); i++) {
 495       temp = (TypedRegion) list.get(i);
 496       System.out.print("Offset: ");
 497       System.out.print(temp.getOffset());
 498       System.out.print(", Length: ");
 499       System.out.print(temp.getLength());
 500       System.out.print(", Type: ");
 501       System.out.print(temp.getType());
 502       System.out.println("");
 503     }
 504     System.out.println("<<<<<List end");
 505   }
 506
 507   private void addOuterPartitions(List list, int offset, int length, FlatNode prev, FlatNode next) {
 508     // limit region
 509     int start = offset;
 510     int end = offset + length;
 511
 512     if (prev != null && start < prev.offset + prev.length) {
 513       start = prev.offset + prev.length;
 514     }
 515
 516     if (next != null && next.offset < end) {
 517       end = next.offset;
 518     }
 519
 520     if (start == end) {
 521       return;
 522     }
 523
 524     if (outerDocument == null) {
 525       //      if (DEBUG) {
 526       //        if (end - start<0) {
 527       //          throw new IndexOutOfBoundsException();
 528       //        }
 529       //      }
 530       list.add(new TypedRegion(start, end - start, getContentType(null, IDocument.DEFAULT_CONTENT_TYPE)));
 531       return;
 532     }
 533
 534    try {
 535       // convert to outer offsets
 536       start = outerDocument.getLocalOffset(start);
 537       end = outerDocument.getLocalOffset(end);
 538       int len = end - start;
 539       if (len >= 0) {
 540         ITypedRegion[] regions = null;
 541         try {
 542           regions = outerDocument.computePartitioning(start, len);
 543         } catch (Exception e) {
 544           // nasty workaround, which prevents cursor from moveing backwards in the editor
 545           // but doesn't solve the partitioning problem
 546           regions = new ITypedRegion[0];
 547           System.out.println("MultiViewerPartitioner#addOuterPartitions failure\n"+"start:"+start +" length:" +len+"\n"+outerDocument.get(start,len));
 548         }
 549         for (int i = 0; i < regions.length; i++) {
 550           ITypedRegion region = regions[i];
 551
 552           // convert back to parent offsets
 553           start = outerDocument.getParentOffset(region.getOffset());
 554           end = start + region.getLength();
 555
 556           if (prev != null) {
 557             offset = prev.offset + prev.length;
 558             if (start < offset) {
 559               start = offset;
 560             }
 561           }
 562
 563           if (next != null) {
 564             offset = next.offset;
 565             if (offset < end) {
 566               end = offset;
 567             }
 568           }
 569           //          if (DEBUG) {
 570           //            if (end - start<0) {
 571           //              showList(list);
 572           //              System.out.print("MultiViewPartitioner::addOuterPartitions - Offset: ");
 573           //              System.out.print(offset);
 574           //              System.out.print(", Start: ");
 575           //              System.out.print(start);
 576           //              System.out.print(", End: ");
 577           //              System.out.print(end);
 578           //              System.out.print(", Type: ");
 579           //              System.out.print(region.getType());
 580           //              System.out.println("");
 581           //              throw new IndexOutOfBoundsException();
 582           //            }
 583           //          }
 584           list.add(new TypedRegion(start, end - start, getContentType(null, region.getType())));
 585         }
 586       }
 587     } catch (BadLocationException x) {
 588     }
 589   }
 590
 591   private void addInnerPartitions(List list, int offset, int length, FlatNode position) {
 592     InnerDocumentView innerDocument = null;
 593     if (position instanceof ViewNode) {
 594       // TODO: revisit condition
 595       innerDocument = ((ViewNode) position).view;
 596     }
 597
 598     if (innerDocument == null) {
 599       // simple partition
 600       //      if (DEBUG) {
 601       //        if (position.length<0) {
 602       //          throw new IndexOutOfBoundsException();
 603       //        }
 604       //      }
 605       list.add(new TypedRegion(position.offset, position.length, getContentType(position.type, null)));
 606       return;
 607     }
 608
 609     // multiplexing to inner view
 610     try {
 611       // limit region
 612       int start = Math.max(offset, position.offset);
 613       int end = Math.min(offset + length, position.offset + position.length);
 614
 615       // convert to document offsets
 616       length = end - start;
 617       offset = innerDocument.getLocalOffset(start);
 618
 619       ITypedRegion[] regions = innerDocument.computePartitioning(offset, length);
 620
 621       for (int i = 0; i < regions.length; i++) {
 622         ITypedRegion region = regions[i];
 623
 624         // convert back to parent offsets
 625         offset = innerDocument.getParentOffset(region.getOffset());
 626         length = region.getLength();
 627         //        if (DEBUG) {
 628         //          if (length<0) {
 629         //            throw new IndexOutOfBoundsException();
 630         //          }
 631         //        }
 632         list.add(new TypedRegion(offset, length, getContentType(position.type, region.getType())));
 633       }
 634     } catch (BadLocationException x) {
 635     }
 636   }
 637
 638   /*
 639    * @see org.eclipse.jface.text.IDocumentPartitioner#getPartition(int)
 640    */
 641   public ITypedRegion getPartition(int offset) {
 642     if (nodes.size() == 0) {
 643       return getOuterPartition(offset, null, null);
 644     }
 645
 646     int index = computeFlatNodeIndex(offset);
 647     if (index < nodes.size()) {
 648       FlatNode next = (FlatNode) nodes.get(index);
 649
 650       if (offset == next.offset) {
 651         return getInnerPartition(offset, next);
 652       }
 653
 654       if (index == 0) {
 655         return getOuterPartition(offset, null, next);
 656       }
 657
 658       FlatNode prev = (FlatNode) nodes.get(index - 1);
 659
 660       if (prev.includes(offset)) {
 661         return getInnerPartition(offset, prev);
 662       }
 663
 664       return getOuterPartition(offset, prev, next);
 665     }
 666
 667     FlatNode prev = (FlatNode) nodes.get(nodes.size() - 1);
 668
 669     if (prev.includes(offset)) {
 670       return getInnerPartition(offset, prev);
 671     }
 672
 673     return getOuterPartition(offset, prev, null);
 674   }
 675
 676   protected ITypedRegion getOuterPartition(int offset, FlatNode prev, FlatNode next) {
 677     try {
 678       int start, end;
 679       String type;
 680
 681       if (outerDocument == null) {
 682         start = 0;
 683         end = document.getLength();
 684         type = getContentType(null, IDocument.DEFAULT_CONTENT_TYPE);
 685       } else {
 686         int outerOffset = outerDocument.getLocalOffset(offset);
 687         //axelcl start
 688         if (outerOffset < 0) {
 689           start = 0;
 690           end = document.getLength();
 691           type = getContentType(null, IDocument.DEFAULT_CONTENT_TYPE);
 692         } else {
 693           //        axelcl end
 694           ITypedRegion region = outerDocument.getPartition(outerOffset);
 695
 696           start = region.getOffset();
 697           end = start + region.getLength();
 698
 699           // convert to parent offset
 700           start = outerDocument.getParentOffset(start);
 701           end = outerDocument.getParentOffset(end);
 702
 703           type = getContentType(null, region.getType());
 704         }
 705       }
 706
 707       if (prev != null) {
 708         offset = prev.offset + prev.length;
 709         if (start < offset) {
 710           start = offset;
 711         }
 712       }
 713
 714       if (next != null) {
 715         offset = next.offset;
 716         if (offset < end) {
 717           end = offset;
 718         }
 719       }
 720
 721       return new TypedRegion(start, end - start, type);
 722     } catch (BadLocationException x) {
 723       x.printStackTrace();
 724       throw new IllegalArgumentException();
 725     }
 726   }
 727
 728   protected ITypedRegion getInnerPartition(int offset, FlatNode position) {
 729     if (position instanceof ViewNode) {
 730       // TODO: revisit condition
 731       InnerDocumentView innerDocument = ((ViewNode) position).view;
 732
 733       if (innerDocument != null) {
 734         // multiplexing to inner view
 735         try {
 736           // convert to inner offset
 737           ITypedRegion region = innerDocument.getPartition(innerDocument.getLocalOffset(offset));
 738
 739           // convert to parent offset
 740           offset = innerDocument.getParentOffset(region.getOffset());
 741
 742           return new TypedRegion(offset, region.getLength(), getContentType(position.type, region.getType()));
 743         } catch (BadLocationException x) {
 744         }
 745       }
 746     }
 747
 748     // simple partition
 749     return new TypedRegion(position.offset, position.length, position.type);
 750   }
 751 }