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