/**
 * Copyright (c) 2019 Eclipse contributors and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 */
package org.eclipse.emf.codegen.presentation;


import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IStateValidationSupport;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IEncodedStorage;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.codegen.CodeGenPlugin;
import org.eclipse.emf.codegen.jet.JETAttributeItem;
import org.eclipse.emf.codegen.jet.JETAttributeListItem;
import org.eclipse.emf.codegen.jet.JETCommentItem;
import org.eclipse.emf.codegen.jet.JETCompilationUnit;
import org.eclipse.emf.codegen.jet.JETCompilationUnit.JETJavaRange;
import org.eclipse.emf.codegen.jet.JETCompileTemplateOperation;
import org.eclipse.emf.codegen.jet.JETDirectiveItem;
import org.eclipse.emf.codegen.jet.JETException;
import org.eclipse.emf.codegen.jet.JETExpressionItem;
import org.eclipse.emf.codegen.jet.JETItem;
import org.eclipse.emf.codegen.jet.JETJavaItem;
import org.eclipse.emf.codegen.jet.JETLiteralItem;
import org.eclipse.emf.codegen.jet.JETMark;
import org.eclipse.emf.codegen.jet.JETNature;
import org.eclipse.emf.codegen.jet.JETParser;
import org.eclipse.emf.codegen.jet.JETProblemListener;
import org.eclipse.emf.codegen.jet.JETRootItem;
import org.eclipse.emf.codegen.jet.JETScriptletItem;
import org.eclipse.emf.codegen.jet.JETSkeleton;
import org.eclipse.emf.codegen.jet.JETSubItem;
import org.eclipse.emf.codegen.jet.JETTokenItem;
import org.eclipse.emf.codegen.jet.JETValueElementItem;
import org.eclipse.emf.codegen.jet.JETValueItem;
import org.eclipse.emf.codegen.util.CodeGenUtil;
import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.SegmentSequence;
import org.eclipse.emf.common.util.URI;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.IBufferChangedListener;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.ILocalVariable;
import org.eclipse.jdt.core.IOpenable;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.ToolFactory;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTRequestor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jdt.ui.JavaElementImageDescriptor;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.actions.IJavaEditorActionDefinitionIds;
import org.eclipse.jdt.ui.actions.OpenAction;
import org.eclipse.jdt.ui.refactoring.RenameSupport;
import org.eclipse.jdt.ui.text.IJavaPartitions;
import org.eclipse.jdt.ui.text.java.hover.IJavaEditorTextHover;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceDialog;
import org.eclipse.jface.preference.PreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.DefaultInformationControl;
import org.eclipse.jface.text.DefaultPositionUpdater;
import org.eclipse.jface.text.DefaultTextHover;
import org.eclipse.jface.text.DocumentEvent;
import org.eclipse.jface.text.DocumentRewriteSessionType;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.IDocumentListener;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.IPositionUpdater;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ISelectionValidator;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.ITextHoverExtension;
import org.eclipse.jface.text.ITextHoverExtension2;
import org.eclipse.jface.text.ITextInputListener;
import org.eclipse.jface.text.ITextPresentationListener;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.ITextViewerExtension;
import org.eclipse.jface.text.ITextViewerExtension2;
import org.eclipse.jface.text.ITextViewerExtension4;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.IUndoManager;
import org.eclipse.jface.text.IUndoManagerExtension;
import org.eclipse.jface.text.IViewportListener;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.TextPresentation;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.contentassist.ContentAssistEvent;
import org.eclipse.jface.text.contentassist.ContentAssistant;
import org.eclipse.jface.text.contentassist.ICompletionListener;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension2;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension3;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension4;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension5;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension6;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
import org.eclipse.jface.text.presentation.IPresentationReconciler;
import org.eclipse.jface.text.presentation.PresentationReconciler;
import org.eclipse.jface.text.quickassist.IQuickAssistAssistant;
import org.eclipse.jface.text.quickassist.IQuickAssistInvocationContext;
import org.eclipse.jface.text.quickassist.IQuickAssistProcessor;
import org.eclipse.jface.text.quickassist.QuickAssistAssistant;
import org.eclipse.jface.text.rules.BufferedRuleBasedScanner;
import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
import org.eclipse.jface.text.rules.ICharacterScanner;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.ITokenScanner;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.AnnotationModel;
import org.eclipse.jface.text.source.DefaultCharacterPairMatcher;
import org.eclipse.jface.text.source.IAnnotationHover;
import org.eclipse.jface.text.source.IAnnotationModel;
import org.eclipse.jface.text.source.IAnnotationPresentation;
import org.eclipse.jface.text.source.ICharacterPairMatcher;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.IVerticalRuler;
import org.eclipse.jface.text.source.ImageUtilities;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.source.TextInvocationContext;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateCompletionProcessor;
import org.eclipse.jface.text.templates.TemplateContext;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.jface.text.templates.TemplateProposal;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.IPostSelectionProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StyledCellLabelProvider;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.jface.viewers.StyledString.Styler;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CaretEvent;
import org.eclipse.swt.custom.CaretListener;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.custom.VerifyKeyListener;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.TypedEvent;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.text.undo.DocumentUndoEvent;
import org.eclipse.text.undo.DocumentUndoManagerRegistry;
import org.eclipse.text.undo.IDocumentUndoListener;
import org.eclipse.text.undo.IDocumentUndoManager;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorActionBarContributor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.INavigationLocation;
import org.eclipse.ui.IPathEditorInput;
import org.eclipse.ui.IPersistableElement;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.ISaveablesLifecycleListener;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IStorageEditorInput;
import org.eclipse.ui.IURIEditorInput;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.NavigationLocation;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.Saveable;
import org.eclipse.ui.SaveablesLifecycleEvent;
import org.eclipse.ui.SubActionBars;
import org.eclipse.ui.dialogs.PreferencesUtil;
import org.eclipse.ui.editors.text.ForwardingDocumentProvider;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
import org.eclipse.ui.handlers.CollapseAllHandler;
import org.eclipse.ui.handlers.ExpandAllHandler;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.texteditor.AbstractDecoratedTextEditor;
import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
import org.eclipse.ui.texteditor.AbstractTextEditor;
import org.eclipse.ui.texteditor.ChainedPreferenceStore;
import org.eclipse.ui.texteditor.ContentAssistAction;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.IDocumentProviderExtension;
import org.eclipse.ui.texteditor.IElementStateListener;
import org.eclipse.ui.texteditor.ITextEditorActionConstants;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
import org.eclipse.ui.texteditor.MarkerAnnotation;
import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;
import org.eclipse.ui.texteditor.spelling.SpellingService;
import org.eclipse.ui.themes.ColorUtil;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;


/**
 * @since 2.19
 */
public final class JETEditor extends AbstractDecoratedTextEditor
{
  public static final String ID = "org.eclipse.emf.codegen.presentation.JETEditorID";

  static final String REFACTOR_QUICKMENU_COMMAND_ID = "org.eclipse.codegen.ui.jet.refactor.quickmenu";

  private static final String REFACTOR_QUICKMENU_MENU_ID = "org.eclipse.codegen.ui.jet.refactor";

  static final String SOURCE_QUICKMENU_COMMAND_ID = "org.eclipse.codegen.ui.jet.source.quickmenu";

  static final String SOURCE_QUICKMENU_MENU_ID = "org.eclipse.codegen.ui.jet.source";

  static final String SELECT_ENCLOSING_JET_ELEMENT_ACTION_ID = "SelectEnclosingJETElement";

  static final String EXTRACT_LOCAL_VARIABLE_ACTION_ID = "ExtractLocalVariable";

  static final String GOTO_BRACKET_COMMAND_ID = "org.eclipse.emf.codegen.ui.jet.goto.matching.bracket";

  static final String SELECT_ENCLOSING_JET_ELEMENT_COMMAND_ID = "org.eclipse.emf.codegen.ui.jet.select.enclosing";

  static final String RENAME_COMMAND_ID = "org.eclipse.codegen.ui.jet.rename";

  static final String RENAME_ACTION_ID = "Rename";

  static final String FORMAT_COMMAND_ID = "org.eclipse.codegen.ui.jet.format";

  static final String FORMAT_ACTION_ID = "Format";

  private static boolean trace;

  private final BracketInserter bracketInserter = new BracketInserter(this);

  private final DelegatingTextHover delegatingTextHover = new DelegatingTextHover(this);

  private final JETDocumentManager jetDocumentManager = new JETDocumentManager(this);

  private final JETBracketMatcher jetBracketMatcher = new JETBracketMatcher(this);

  private final List<Runnable> disposables = new ArrayList<Runnable>();

  private final AtomicReference<JETCompilerResult> pendingJETCompilerResult = new AtomicReference<JETCompilerResult>();;

  private JETCompilerResult jetCompilerResult;

  private JavaEditor javaEditor;

  private long expectedModificationStamp;

  private JETContentOutlinePage contentOutlinePage;

  private JETBreadcrumbViewer breadcrumbViewer;

  private Runnable pendingUntilDocumentsAvailable;

  private Runnable dismissLandingPage;

  private boolean isSaving;

  private boolean isShowingContentAssist;

  private TrackedPosition jetPosition = new TrackedPosition(TrackedPosition.Type.JET);

  private TrackedPosition javaPosition = new TrackedPosition(TrackedPosition.Type.JAVA);

  private int[] styleRangeOffsets;

  private JETToken[] jetTokens;

  private SelectionSynchronizer selectionSynchronizer;

  private Runnable deferredInvalidatePresentation;

  private boolean editorContextMenuAboutToShow;

  public JETEditor()
  {
    jetPosition.setOpposite(javaPosition);
  }

  JETNature getJETNature()
  {
    IFile file = getEditorInputFile();
    return file == null ? null : JETNature.getRuntime(file.getProject());
  }

  @Override
  public IEditorInput getEditorInput()
  {
    return editorContextMenuAboutToShow ? jetDocumentManager.getEditorInput() : super.getEditorInput();
  }

  SourceViewer getJETSourceViewer()
  {
    return (SourceViewer)getSourceViewer();
  }

  JavaEditor getJavaEditor()
  {
    return javaEditor;
  }

  SourceViewer getJavaSourceViewer()
  {
    return getJavaEditor().getJavaSourceViewer();
  }

  TrackedPosition getJavaPosition()
  {
    return javaPosition;
  }

  TrackedPosition getJETPosition()
  {
    return jetPosition;
  }

  boolean isJavaEditorInSync()
  {
    return expectedModificationStamp == getModificationStamp();
  }

  long getModificationStamp()
  {
    IDocument document = getSourceViewer().getDocument();
    return document == null ? 0 : ((IDocumentExtension4)document).getModificationStamp();
  }

  void resetExpectedModificationStamp()
  {
    expectedModificationStamp = 0;
  }

  void setExpectedModificationStamp()
  {
    expectedModificationStamp = getModificationStamp();
  }

  JETDocumentManager getDocumentManager()
  {
    return jetDocumentManager;
  }

  int getFileID()
  {
    return jetDocumentManager.getFileID();
  }

  IFile getEditorInputFile()
  {
    return toFile(getEditorInput());
  }

  JETBreadcrumbViewer getBreadcrumbViewer()
  {
    return breadcrumbViewer;
  }

  JETCompilerResult getCompilerResult()
  {
    return jetCompilerResult;
  }

  JETCompilationUnit getCompilationUnit()
  {
    return jetCompilerResult == null ? null : jetCompilerResult.getCompilationUnit();
  }

  void setShowingContentAssist(boolean isShowingContentAssist)
  {
    this.isShowingContentAssist = isShowingContentAssist;
    if (!isShowingContentAssist)
    {
      jetDocumentManager.setEnableJavaSynchronization(true);
    }
  }

  void handleCompilerResult(final JETCompilerResult jetCompilerResult)
  {
    // This is called from the JETDynamicCompiler's thread.
    JETCompilerResult oldJETCompilerResult = pendingJETCompilerResult.getAndSet(jetCompilerResult);

    // If there is not a value that was already pending consumption, dispatch a new runnable to the UI thread.
    if (oldJETCompilerResult == null)
    {
      getSite().getShell().getDisplay().asyncExec(new Runnable()
        {
          public void run()
          {
            // If the pending result is still not consumed by waitForCompilerResult, consume it now.
            JETCompilerResult newJETCompilerResult = pendingJETCompilerResult.getAndSet(null);
            if (newJETCompilerResult != null)
            {
              setCompilerResult(newJETCompilerResult);
            }
          }
        });
    }
  }

  void waitForCompilerResult(long timeInMillis)
  {
    long count = timeInMillis / 100;
    for (int i = 0; i < count; ++i)
    {
      JETCompilerResult jetCompilerResult = pendingJETCompilerResult.getAndSet(null);
      if (jetCompilerResult == null)
      {
        try
        {
          Thread.sleep(100);
        }
        catch (InterruptedException exception)
        {
          Thread.interrupted();
        }
      }
      else
      {
        setCompilerResult(jetCompilerResult);
        break;
      }
    }
  }

  void setCompilerResult(JETCompilerResult jetCompilerResult)
  {
    if (!isShowingContentAssist)
    {
      this.jetCompilerResult = jetCompilerResult;

      jetDocumentManager.setCompilerResult(jetCompilerResult);

      handleProblems(getFileID());

      IFile javaFile = jetCompilerResult.getJavaFile();
      JETCompilationUnit jetCompilationUnit = jetCompilerResult.getCompilationUnit();
      if (javaFile != null)
      {
        final ISourceViewer jetSourceViewer = getSourceViewer();
        setExpectedModificationStamp();

        ISourceViewer javaSourceViewer = getJavaSourceViewer();
        StyledText javaTextWidget = javaSourceViewer.getTextWidget();
        try
        {
          javaTextWidget.setRedraw(false);

          String compilationUnit = jetCompilationUnit.getJavaCompilationUnit();
          javaEditor.setInput(javaFile, compilationUnit);

          IDocument document = javaSourceViewer.getDocument();
          if (document != null)
          {
            String oldDocument = document.get();
            if (!compilationUnit.equals(oldDocument))
            {
              document.set(compilationUnit);
            }
            else
            {
              invalidateVisibleTextPresentation(true);
            }

            // Synchronize the cursor/selection.
            jetSourceViewer.getTextWidget().notifyListeners(SWT.Selection, new Event());
          }
        }
        finally
        {
          javaTextWidget.setRedraw(true);
        }
      }

      if (jetCompilationUnit != null && pendingUntilDocumentsAvailable != null)
      {
        try
        {
          pendingUntilDocumentsAvailable.run();
        }
        finally
        {
          pendingUntilDocumentsAvailable = null;
        }
      }

      if (dismissLandingPage != null)
      {
        dismissLandingPage.run();
      }

      selectionSynchronizer.sync(getSourceViewer());
    }
  }

  List<JETJavaRange> getRanges()
  {
    JETCompilationUnit compilerResult = getCompilationUnit();
    return compilerResult == null ? Collections.<JETJavaRange> emptyList() : compilerResult.getRanges();
  }

  JETItem getJETItem(int templateOffset, boolean leaf)
  {
    JETCompilationUnit compilerResult = getCompilationUnit();
    return compilerResult == null ? null : compilerResult.getJETItem(getFileID(), templateOffset, leaf);
  }

  Position getCorrespondingJavaPosition(int templateOffset, int templateLength)
  {
    JETCompilationUnit compilerResult = getCompilationUnit();
    if (compilerResult != null)
    {
      int[] correspondingJavaPoint = compilerResult.getCorrespondingJavaPoint(getFileID(), templateOffset, templateLength);
      if (correspondingJavaPoint != null)
      {
        return new Position(correspondingJavaPoint[0], correspondingJavaPoint[1]);
      }
    }

    return null;
  }

  int getCorrespondingTemplateFileID(int javaOffset)
  {
    JETCompilationUnit compilerResult = getCompilationUnit();
    return compilerResult == null ? -1 : compilerResult.getCorrespondingTemplateFileID(javaOffset);
  }

  Position getCorrespondingTemplatePosition(int javaOffset, int javaLength)
  {
    JETCompilationUnit compilerResult = getCompilationUnit();
    if (compilerResult != null)
    {
      int[] correspondingTemplatePoint = compilerResult.getCorrespondingTemplatePoint(getFileID(), javaOffset, javaLength);
      if (correspondingTemplatePoint != null)
      {
        return new Position(correspondingTemplatePoint[0], correspondingTemplatePoint[1]);
      }
    }
    return null;
  }

  void handleFileIDChanged(int fileID)
  {
    firePropertyChange(PROP_DIRTY);
    handleProblems(fileID);
  }

  void handleProblems(int fileID)
  {
    if (jetCompilerResult != null)
    {
      applyProblemAnnotations(jetCompilerResult.getProblems(fileID));
    }
  }

  void applyProblemAnnotations(List<JETProblemAnnotation> jetProblemAnnotations)
  {
    SourceViewer sourceViewer = getJETSourceViewer();
    IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
    List<Annotation> annotationsToRemove = new ArrayList<Annotation>();
    for (Iterator<Annotation> i = annotationModel.getAnnotationIterator(); i.hasNext();)
    {
      Annotation annotation = i.next();
      if (annotation instanceof JETProblemAnnotation)
      {
        annotationsToRemove.add(annotation);
      }
      else if (annotation instanceof MarkerAnnotation && isDirty())
      {
        Position position = annotationModel.getPosition(annotation);
        annotationModel.addAnnotation(new JETProblemAnnotation((MarkerAnnotation)annotation, position), position);
      }
    }

    for (Annotation annotation : annotationsToRemove)
    {
      annotationModel.removeAnnotation(annotation);
    }

    for (JETProblemAnnotation jetProblemAnnotation : jetProblemAnnotations)
    {
      Position position = jetProblemAnnotation.getPosition();
      annotationModel.addAnnotation(jetProblemAnnotation, position);
    }
  }

  @Override
  protected void initializeEditor()
  {
    super.initializeEditor();

    configureInsertMode(SMART_INSERT, true);
    configureInsertMode(INSERT, false);
    configureInsertMode(INSERT, true);
    setInsertMode(SMART_INSERT);

    IPreferenceStore preferenceStore = getPreferenceStore();
    IPreferenceStore jetPreferenceStore = CodeGenUIPlugin.getPlugin().getPreferenceStore();
    ChainedPreferenceStore chainedPreferenceStore = new ChainedPreferenceStore(new IPreferenceStore []{ jetPreferenceStore, preferenceStore })
      {
        @Override
        public boolean getBoolean(String name)
        {
          if ("matchingBrackets".equals(name))
          {
            return true;
          }

          return !SpellingService.PREFERENCE_SPELLING_ENABLED.equals(name) && super.getBoolean(name);
        }
      };
    setPreferenceStore(chainedPreferenceStore);
    setSourceViewerConfiguration(new JETSourceViewerConfiguration(chainedPreferenceStore, this));
  }

  @Override
  public void createPartControl(Composite parent)
  {
    final SashForm sashForm = new SashForm(parent, SWT.VERTICAL);

    final Composite composite = new Composite(sashForm, SWT.NONE);
    GridLayout gridLayout = new GridLayout();
    gridLayout.marginHeight = 0;
    gridLayout.marginWidth = 0;
    gridLayout.verticalSpacing = 0;
    gridLayout.horizontalSpacing = 0;
    composite.setLayout(gridLayout);

    breadcrumbViewer = new JETBreadcrumbViewer(composite, SWT.HORIZONTAL)
      {
        @Override
        public void configureDropDownViewer(TreeViewer viewer, Object input)
        {
          viewer.setLabelProvider(contentOutlinePage.newLabelProvider());
          viewer.setContentProvider(contentOutlinePage.getContentProvider());
        }
      };
    GridData breadcrumbLayoutData = new GridData(SWT.FILL, SWT.FILL, true, false);
    breadcrumbViewer.getControl().setLayoutData(breadcrumbLayoutData);

    Composite jetSourceViewerComposite = new Composite(composite, SWT.NONE);
    jetSourceViewerComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    jetSourceViewerComposite.setLayout(new FillLayout());

    super.createPartControl(jetSourceViewerComposite);

    ToolBarManager toolBarManager = new ToolBarManager(SWT.FLAT);

    final ImageDescriptor up = CodeGenUIPlugin.getPlugin().getImage("full/up.png");
    final ImageDescriptor down = CodeGenUIPlugin.getPlugin().getImage("full/down.png");
    final Action toggleAction = new Action("", IAction.AS_PUSH_BUTTON)
      {
        @Override
        public void run()
        {
          if (sashForm.getMaximizedControl() == null)
          {
            sashForm.setMaximizedControl(composite);
            setImageDescriptor(up);
          }
          else
          {
            sashForm.setMaximizedControl(null);
            setImageDescriptor(down);
          }
        }
      };
    toggleAction.setImageDescriptor(down);
    toolBarManager.add(toggleAction);

    ToolBar toolBar = toolBarManager.createControl(composite);

    GridData toolBarLayoutData = new GridData(SWT.CENTER, SWT.BOTTOM, true, false);
    toolBarLayoutData.heightHint = 11;
    toolBar.setLayoutData(toolBarLayoutData);

    StyledText sourceViewerStyledText = getSourceViewer().getTextWidget();
    Color sourceViewerBackground = sourceViewerStyledText.getBackground();
    breadcrumbViewer.getControl().setBackground(sourceViewerBackground);
    composite.setBackground(sourceViewerStyledText.getBackground());
    IMenuManager contextMenu = (IMenuManager)sourceViewerStyledText.getMenu().getData("org.eclipse.jface.action.MenuManager.managerKey");
    contextMenu.addMenuListener(new IMenuListener()
      {
        public void menuAboutToShow(IMenuManager manager)
        {
          editorContextMenuAboutToShow = false;
        }
      });

    JETContentOutlinePage contentOutlinePage = getContentOutlinePage();
    breadcrumbViewer.setLabelProvider(contentOutlinePage.newLabelProvider());
    breadcrumbViewer.setContentProvider(contentOutlinePage.getContentProvider());
    breadcrumbViewer.setInput(contentOutlinePage.itemManager.getRootItem());

    jetDocumentManager.initializeDocumentManager();

    try
    {
      javaEditor = new JavaEditor(this);
      javaEditor.init(getEditorSite(), getEditorInput());

      final Composite javaComposite = new Composite(sashForm, SWT.NONE);
      final StackLayout stackLayout = new StackLayout();
      javaComposite.setLayout(stackLayout);

      javaEditor.createPartControl(javaComposite);

      final Control[] javaEditorChildren = javaComposite.getChildren();

      final ScrolledComposite scrolledComposite = new ScrolledComposite(javaComposite, SWT.V_SCROLL | SWT.H_SCROLL);
      scrolledComposite.setExpandHorizontal(true);
      scrolledComposite.setExpandVertical(true);
      scrolledComposite.setAlwaysShowScrollBars(false);

      final StyledText landingPage = new StyledText(scrolledComposite, SWT.READ_ONLY | SWT.NO_FOCUS);
      landingPage.setBackground(sourceViewerStyledText.getBackground());
      scrolledComposite.setContent(landingPage);

      final Runnable updateLandingPageInfo = new Runnable()
        {
          public void run()
          {
            StyledString landingPageInfo = generateLandingPageInfo(landingPage.getLineDelimiter());
            landingPage.setText(landingPageInfo.toString());
            landingPage.setStyleRanges(landingPageInfo.getStyleRanges());
            landingPage.redraw();

            landingPage.pack(true);

            Point landingPageSize = landingPage.getSize();
            scrolledComposite.setMinWidth(landingPageSize.x);
            scrolledComposite.setMinHeight(landingPageSize.y);
          }
        };
      updateLandingPageInfo.run();

      stackLayout.topControl = scrolledComposite;

      final ImageDescriptor star = CodeGenUIPlugin.getPlugin().getImage("full/star.png");
      final ImageDescriptor blank = CodeGenUIPlugin.getPlugin().getImage("full/blank.png");
      final Action showInfoAction = new Action("", IAction.AS_PUSH_BUTTON)
        {
          @Override
          public void run()
          {
            if (stackLayout.topControl == scrolledComposite)
            {
              stackLayout.topControl = javaEditorChildren[0];
            }
            else
            {
              stackLayout.topControl = scrolledComposite;
              updateLandingPageInfo.run();
            }

            if (sashForm.getMaximizedControl() == composite)
            {
              sashForm.setMaximizedControl(null);
              toggleAction.setImageDescriptor(down);
            }

            javaComposite.layout();
          }
        };
      showInfoAction.setImageDescriptor(star);
      showInfoAction.setId("show-info");
      toolBarManager.add(showInfoAction);

      toolBarManager.update(true);

      class HyperlinkListener implements MouseTrackListener, MouseMoveListener, MouseListener
      {
        final Cursor defaultCursor = landingPage.getCursor();

        final Cursor handCursor = landingPage.getDisplay().getSystemCursor(SWT.CURSOR_HAND);

        final Runnable infoActionAnimator = new Runnable()
          {
            public void run()
            {
              if (hyperLinkRange != null && hyperLinkRange.length == 1)
              {
                showInfoAction.setImageDescriptor(showInfoAction.getImageDescriptor() == blank ? star : blank);
                landingPage.getDisplay().timerExec(300, this);
              }
              else
              {
                showInfoAction.setImageDescriptor(star);
              }
            }
          };

        StyleRange hyperLinkRange;

        public void mouseDoubleClick(MouseEvent event)
        {
          clearHyperlink();
        }

        public void mouseDown(MouseEvent event)
        {
          if (hyperLinkRange != null)
          {
            if (hyperLinkRange.length == 1)
            {
              showInfoAction.run();
            }
            else
            {
              landingPage.getDisplay().asyncExec(new Runnable()
                {
                  final URI documentURI = URI.createPlatformResourceURI(landingPage.getText(hyperLinkRange.start, hyperLinkRange.start + hyperLinkRange.length - 1), true);

                  public void run()
                  {
                    IEditorPart editorPart = open(getEditorSite(), documentURI.toString());
                    if (editorPart instanceof JETEditor)
                    {
                      ((JETEditor)editorPart).selectAndReveal(getEditorInput(), 0, 0);
                    }
                  }
                });
            }
          }

          clearHyperlink();
        }

        public void mouseUp(MouseEvent event)
        {
          clearHyperlink();
        }

        public void mouseEnter(MouseEvent event)
        {
          clearHyperlink();
        }

        public void mouseExit(MouseEvent event)
        {
          clearHyperlink();
        }

        public void mouseHover(MouseEvent event)
        {
        }

        public void mouseMove(MouseEvent event)
        {
          updateStyleRange(event);
        }

        private void clearHyperlink()
        {
          if (hyperLinkRange != null)
          {
            hyperLinkRange.fontStyle = SWT.NORMAL;
            hyperLinkRange.underline = false;
            landingPage.setStyleRange(hyperLinkRange);
            hyperLinkRange = null;
            landingPage.setCursor(defaultCursor);
          }
        }

        @SuppressWarnings("deprecation")
        private int getOffset(MouseEvent event)
        {
          try
          {
            try
            {
              return (Integer)landingPage.getClass().getMethod("getOffsetAtPoint", Point.class).invoke(landingPage, new Point(event.x, event.y));
            }
            catch (Exception exception)
            {
            }

            return landingPage.getOffsetAtLocation(new Point(event.x, event.y));
          }
          catch (IllegalArgumentException exception)
          {
            return -1;
          }
        }

        private void updateStyleRange(MouseEvent event)
        {
          StyleRange oldHyperLinkRange = hyperLinkRange;
          hyperLinkRange = null;
          int offsetAtPoint = getOffset(event);
          if (offsetAtPoint != -1)
          {
            StyleRange styleRange = landingPage.getStyleRangeAtOffset(offsetAtPoint);
            if (styleRange != null)
            {
              if (styleRange.data instanceof StyleRange)
              {
                hyperLinkRange = (StyleRange)styleRange.data;
                hyperLinkRange.underline = true;
                hyperLinkRange.fontStyle = SWT.BOLD;
                landingPage.setStyleRange(hyperLinkRange);
                landingPage.setCursor(handCursor);
                infoActionAnimator.run();
              }
            }
          }

          if (oldHyperLinkRange != null && oldHyperLinkRange != hyperLinkRange)
          {
            oldHyperLinkRange.fontStyle = SWT.NORMAL;
            oldHyperLinkRange.underline = false;
            landingPage.setStyleRange(oldHyperLinkRange);
            if (hyperLinkRange == null)
            {
              landingPage.setCursor(defaultCursor);
            }
          }
        }
      }

      HyperlinkListener hyperlinkListener = new HyperlinkListener();
      landingPage.addMouseTrackListener(hyperlinkListener);
      landingPage.addMouseListener(hyperlinkListener);
      landingPage.addMouseMoveListener(hyperlinkListener);
      dismissLandingPage = new Runnable()
        {
          public void run()
          {
            dismissLandingPage = null;

            JETCompilationUnit compilationUnit = getCompilationUnit();
            if (compilationUnit != null)
            {
              for (JETException problem : compilationUnit.getProblems())
              {
                String problemKey = problem.getProblemKey();
                if (JETProblemListener.FILE_NOT_A_TEMPLATE.equals(problemKey) || JETProblemListener.FILE_NOT_ON_TEMPLATE_SOURCE_PATH.equals(problemKey))
                {
                  return;
                }
              }

              stackLayout.topControl = javaEditorChildren[0];
              toggleAction.run();
              javaComposite.layout();
            }
          }
        };

      selectionSynchronizer = new SelectionSynchronizer(this, javaEditor);

      delegatingTextHover.setEditor(javaEditor);

      new VisibleCaretHandler(sourceViewerStyledText, javaEditor.getJavaSourceViewer().getTextWidget());
    }
    catch (PartInitException exception)
    {
      throw new RuntimeException(exception);
    }

    if (fSourceViewerDecorationSupport != null)
    {
      fSourceViewerDecorationSupport.install(getPreferenceStore());
    }

    new ViewPortHandler(this);

    setAction(SELECT_ENCLOSING_JET_ELEMENT_ACTION_ID, new SelectEnclosingJETElementAction(this));
    setAction(RENAME_ACTION_ID, new JETRenameLocalVariableAction(this));
    setAction(FORMAT_ACTION_ID, new JETFormatAction(this));
  }

  private StyledString generateLandingPageInfo(String lineDelimiter)
  {
    StyledString styledString = new StyledString(lineDelimiter);
    IEditorInput editorInput = getEditorInput();
    IFile file = toFile(editorInput);
    String indent = "      ";
    if (file == null)
    {
      URI uri = toURI(editorInput);
      String name = uri == null ? editorInput.getName() : uri.toString();
      styledString.append(indent);
      styledString.append("The file ");
      styledString.append(name, StyledString.DECORATIONS_STYLER);
      styledString.append(" cannot be compiled because it is not located in the workspace.");
    }
    else if (getJETNature() == null)
    {
      styledString.append(indent);
      styledString.append("The file ");
      styledString.append(file.getFullPath().toString(), StyledString.DECORATIONS_STYLER);
      styledString.append(" cannot be compiled because it is not in a project with a JET nature.");
      styledString.append(lineDelimiter);
      styledString.append(lineDelimiter);

      IJavaProject javaProject = JavaCore.create(file.getProject());
      boolean isWellFormedJavaProject = false;
      try
      {
        isWellFormedJavaProject = javaProject.isStructureKnown();
      }
      catch (JavaModelException e)
      {
      }

      if (!isWellFormedJavaProject)
      {
        styledString.append(indent);
        styledString.append("Furthermore, its containing project ");
        styledString.append(file.getParent().getFullPath().toString(), StyledString.DECORATIONS_STYLER);
        styledString.append(" is not in a project with a properly configured Java nature.");
        styledString.append(lineDelimiter);
        styledString.append(lineDelimiter);
      }

      styledString.append(indent);
      styledString.append("Use ");
      styledString.append(
        "File \u2192 New \u2192 Other... \u2192 Java Emitter Templates \u2192 Convert Projects to JET Projects",
        JETContentOutlinePage.Item.getFontStyler(SWT.ITALIC));
      styledString.append(" to convert a Java project into a JET project.");
      styledString.append(lineDelimiter);
      styledString.append(lineDelimiter);
      styledString.append(indent);
      styledString.append("You will need to reopen this editor after having done so.");
    }
    else if (getJETNature().getJavaSourceContainer() == null)
    {
      styledString.append(indent);
      styledString.append("The file ");
      styledString.append(file.getFullPath().toString(), StyledString.DECORATIONS_STYLER);
      styledString.append(" cannot be compiled because the JET nature is not properly configured.");
      styledString.append(lineDelimiter);
    }
    else
    {
      JETCompilationUnit compilationUnit = getCompilationUnit();
      String className = null;
      boolean notOnSourcePath = false;
      if (compilationUnit != null)
      {
        className = compilationUnit.getClassName();
        for (JETException problem : compilationUnit.getProblems())
        {
          if (JETProblemListener.FILE_NOT_ON_TEMPLATE_SOURCE_PATH.equals(problem.getProblemKey()))
          {
            notOnSourcePath = true;
            break;
          }
        }
      }

      styledString.append(indent);
      styledString.append("The file ");
      styledString.append(file.getFullPath().toString(), StyledString.DECORATIONS_STYLER);
      styledString.append(" is being compiled.");
      styledString.append(lineDelimiter);
      styledString.append(lineDelimiter);

      Styler problemStyler = new Styler()
        {
          @Override
          public void applyStyles(TextStyle textStyle)
          {
            textStyle.foreground = ColorManager.INSTANCE.getForeground("directive");
          }
        };

      String fileExtension = file.getFileExtension();
      boolean isNotTemplate = fileExtension == null || !fileExtension.endsWith("jet");
      if (isNotTemplate)
      {
        styledString.append(indent);
        styledString.append("However, the file is not a root JET template.", problemStyler);
        styledString.append(lineDelimiter);
        styledString.append(lineDelimiter);

        styledString.append(indent);
        styledString.append("A root JET template must have have a file extension that ends with ");
        styledString.append("jet", StyledString.DECORATIONS_STYLER);
        styledString.append(", e.g, ");
        styledString.append("MyTemplate.jet", StyledString.DECORATIONS_STYLER);
        styledString.append(" or ");
        styledString.append("MyTemplate.xmljet", StyledString.DECORATIONS_STYLER);
        styledString.append(".");
        styledString.append(lineDelimiter);
        styledString.append(lineDelimiter);
      }
      else
      {
        if (notOnSourcePath)
        {
          styledString.append(indent);
          styledString.append("The class ");
          if (className != null)
          {
            styledString.append(className, StyledString.DECORATIONS_STYLER);
            styledString.append(' ');
          }
          styledString.append("would be generated in ");
          styledString.append(getJETNature().getJavaSourceContainer().getFullPath().toString(), StyledString.DECORATIONS_STYLER);
          styledString.append(", but the template is not on the template path and it will not be built when the project builds.");
          styledString.append(lineDelimiter);
          styledString.append(lineDelimiter);
        }
        else
        {
          styledString.append(indent);
          styledString.append("The class ");
          if (className != null)
          {
            styledString.append(className, StyledString.DECORATIONS_STYLER);
            styledString.append(' ');
          }
          styledString.append("will be generated in ");
          styledString.append(getJETNature().getJavaSourceContainer().getFullPath().toString(), StyledString.DECORATIONS_STYLER);
          styledString.append(".");
          styledString.append(lineDelimiter);
          styledString.append(lineDelimiter);
        }
      }

      styledString.append(indent);
      styledString.append("The following template path is used:");
      styledString.append(lineDelimiter);
      styledString.append(lineDelimiter);
      List<Object> templateSourceContainers = getJETNature().getTemplateSourceContainers();
      for (Object container : getJETNature().getTemplateContainers())
      {
        String containerName = container instanceof IContainer ? ((IContainer)container).getFullPath().toString() : container.toString();
        styledString.append(indent);
        styledString.append("    ");
        styledString.append("@ ", templateSourceContainers.contains(container) ? new Styler()
          {
            @Override
            public void applyStyles(TextStyle textStyle)
            {
              textStyle.foreground = getSourceViewer().getTextWidget().getBackground();
            }
          } : StyledString.COUNTER_STYLER);
        styledString.append(containerName, StyledString.DECORATIONS_STYLER);
        styledString.append(lineDelimiter);
      }

      styledString.append(lineDelimiter);
      styledString.append(indent);
      styledString.append("Click the tiny ", StyledString.COUNTER_STYLER);
      styledString.append("\u2605", new Styler()
        {
          @Override
          public void applyStyles(TextStyle textStyle)
          {
            textStyle.data = textStyle;
            textStyle.foreground = ColorManager.INSTANCE.getColor(230, 179, 60);
          }
        });
      styledString.append(" icon on the divider above to preview the Java results.", StyledString.COUNTER_STYLER);
      if (isNotTemplate)
      {
        styledString.append("  Unresolved names will not be reported.", problemStyler);
      }

      styledString.append(lineDelimiter);
      styledString.append(lineDelimiter);

      Set<URI> includingTemplates = JETNature.getIncludingTemplates(toURI(file));
      if (!includingTemplates.isEmpty())
      {
        Set<String> values = new TreeSet<String>();
        for (URI includingTemplate : includingTemplates)
        {
          values.add(includingTemplate.isPlatformResource() ? includingTemplate.toPlatformString(true) : includingTemplate.toString());
        }

        styledString.append(indent);
        styledString.append("This template is included by the following templates. Click any of these links to open this template in the including context:");
        styledString.append(lineDelimiter);
        styledString.append(lineDelimiter);
        for (String includingTemplate : values)
        {
          styledString.append(indent);
          styledString.append(indent);
          Styler linkStyler = new Styler()
            {
              @Override
              public void applyStyles(TextStyle textStyle)
              {
                StyledString.DECORATIONS_STYLER.applyStyles(textStyle);
                textStyle.data = textStyle;
              }
            };

          styledString.append(includingTemplate, linkStyler);
          styledString.append(lineDelimiter);
        }
      }
    }

    return styledString;
  }

  void invalidateVisibleTextPresentation(boolean defer)
  {
    ISourceViewer jetSourceViewer = getSourceViewer();
    if (defer)
    {
      final StyledText textWidget = jetSourceViewer.getTextWidget();
      deferredInvalidatePresentation = new Runnable()
        {
          public void run()
          {
            if (deferredInvalidatePresentation == this && !textWidget.isDisposed())
            {
              invalidateVisibleTextPresentation(false);
            }
          }
        };
      textWidget.getDisplay().timerExec(200, deferredInvalidatePresentation);
    }
    else
    {
      deferredInvalidatePresentation = null;
      int start = jetSourceViewer.getTopIndexStartOffset();
      int end = jetSourceViewer.getBottomIndexEndOffset();
      ((ITextViewerExtension2)jetSourceViewer).invalidateTextPresentation(start, end - start);
    }
  }

  @Override
  protected void doSetInput(IEditorInput input) throws CoreException
  {
    super.doSetInput(input);

    jetDocumentManager.handleInputChanged(input);
  }

  @Override
  protected ISourceViewer createSourceViewer(Composite parent, IVerticalRuler ruler, int styles)
  {
    ISourceViewer sourceViewer = super.createSourceViewer(parent, ruler, styles);

    ColorManager.INSTANCE.register(sourceViewer);

    if (sourceViewer instanceof ITextViewerExtension)
    {
      ((ITextViewerExtension)sourceViewer).prependVerifyKeyListener(bracketInserter);
    }

    return sourceViewer;
  }

  @SuppressWarnings("restriction")
  @Override
  protected void createActions()
  {
    super.createActions();

    Action action = new ContentAssistAction(CodeGenUIPlugin.getResourceBundle(), "_UI_ContentAssistProposal_", this);
    String id = ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS;
    action.setActionDefinitionId(id);
    setAction("ContentAssistProposal", action);
    markAsStateDependentAction("ContentAssistProposal", true);

    final IHandlerService service = (IHandlerService)getSite().getService(IHandlerService.class);

    org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator refactorMenuCreator = new org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator(getJavaEditor())
      {
        @Override
        protected void fillMenu(IMenuManager menu)
        {
          addRefactorActions(menu);
        }
      };

    final IHandlerActivation refactorHandlerActivation = service.activateHandler(REFACTOR_QUICKMENU_COMMAND_ID, refactorMenuCreator.createHandler());

    org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator sourceMenuCreator = new org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator(getJavaEditor())
      {
        @Override
        protected void fillMenu(IMenuManager menu)
        {
          addSourceActions(menu);
        }
      };

    final IHandlerActivation sourceHandlerActivation = service.activateHandler(SOURCE_QUICKMENU_COMMAND_ID, sourceMenuCreator.createHandler());

    disposables.add(new Runnable()
      {
        public void run()
        {
          service.deactivateHandler(refactorHandlerActivation);
          service.deactivateHandler(sourceHandlerActivation);
        }
      });
  }

  @Override
  protected void editorContextMenuAboutToShow(IMenuManager menu)
  {
    editorContextMenuAboutToShow = true;
    super.editorContextMenuAboutToShow(menu);

    Action colorPreferencesAction = new Action(CodeGenUIPlugin.getPlugin().getString("_UI_JETColorPreferences_label"), CodeGenUIPlugin.getPlugin().getImage("full/obj16/JETFile"))
      {
        @Override
        public void run()
        {
          JETToken token = getTokenAtSelection(0);
          String matchingProperty = "selectColor:" + ColorManager.INSTANCE.getProperty(token);
          PreferenceDialog preferenceDialog = PreferencesUtil.createPreferenceDialogOn(
            getSite().getShell(),
            "org.eclipse.ui.preferencePages.ColorsAndFonts",
            null,
            matchingProperty);
          preferenceDialog.open();
        }
      };

    menu.insertAfter(ITextEditorActionConstants.CONTEXT_PREFERENCES, colorPreferencesAction);

    IContributionItem quickAssist = menu.find(ITextEditorActionConstants.QUICK_ASSIST);
    if (quickAssist != null)
    {
      MenuManager refactorSubmenu = new MenuManager("Refac&tor", REFACTOR_QUICKMENU_MENU_ID);
      refactorSubmenu.setActionDefinitionId(REFACTOR_QUICKMENU_COMMAND_ID);

      addRefactorActions(refactorSubmenu);
      menu.insertAfter(ITextEditorActionConstants.QUICK_ASSIST, refactorSubmenu);

      MenuManager sourceSubmenu = new MenuManager("&Source", SOURCE_QUICKMENU_MENU_ID);
      sourceSubmenu.setActionDefinitionId(SOURCE_QUICKMENU_COMMAND_ID);

      addSourceActions(sourceSubmenu);
      menu.insertAfter(ITextEditorActionConstants.QUICK_ASSIST, sourceSubmenu);
    }
  }

  void addRefactorActions(IMenuManager refactorSubmenu)
  {
    IAction action = getAction(RENAME_ACTION_ID);
    refactorSubmenu.add(action);

    action = javaEditor.getAction(EXTRACT_LOCAL_VARIABLE_ACTION_ID);
    refactorSubmenu.add(action);
  }

  void addSourceActions(IMenuManager sourceSubmenu)
  {
    IAction action = getAction(FORMAT_ACTION_ID);
    sourceSubmenu.add(action);
  }

  @Override
  public boolean isSaveAsAllowed()
  {
    return false;
  }

  @Override
  public void dispose()
  {
    jetDocumentManager.dispose();

    super.dispose();

    if (javaEditor != null)
    {
      ((IWorkbenchPart)javaEditor).dispose();
    }

    if (contentOutlinePage != null)
    {
      contentOutlinePage.dispose();
    }

    javaPosition.dispose();
    jetPosition.dispose();

    for (Runnable runnable : disposables)
    {
      runnable.run();
    }
    disposables.clear();
  }

  @Override
  public void saveState(IMemento memento)
  {
    super.saveState(memento);
    memento.putString("document-id", getDocumentManager().getDocumentID());
  }

  @Override
  protected void doRestoreState(IMemento memento)
  {
    String documentID = memento.getString("document-id");
    if (documentID != null)
    {
      getDocumentManager().setDocumentID(documentID);
    }
    super.doRestoreState(memento);
  }

  @Override
  public INavigationLocation createEmptyNavigationLocation()
  {
    return new JETTextSelectionNavigationLocation(this, false);
  }

  @Override
  public INavigationLocation createNavigationLocation()
  {
    return new JETTextSelectionNavigationLocation(this, true);
  }

  @Override
  protected void editorSaved()
  {
    INavigationLocation[] locations = getSite().getPage().getNavigationHistory().getLocations();
    IEditorInput input = getEditorInput();
    for (int i = 0; i < locations.length; i++)
    {
      if (locations[i] instanceof JETTextSelectionNavigationLocation)
      {
        if (input.equals(locations[i].getInput()))
        {
          JETTextSelectionNavigationLocation location = (JETTextSelectionNavigationLocation)locations[i];
          location.partSaved(this);
        }
      }
    }
  }

  @Override
  protected void performSave(boolean overwrite, IProgressMonitor progressMonitor)
  {
    isSaving = true;
    try
    {
      jetDocumentManager.performSave(overwrite, progressMonitor);
    }
    finally
    {
      isSaving = false;
    }
  }

  @Override
  protected void safelySanityCheckState(IEditorInput input)
  {
    if (!isSaving)
    {
      super.safelySanityCheckState(input);
    }
  }

  @Override
  protected void performRevert()
  {
    jetDocumentManager.performRevert();
  }

  void selectAndReveal(IDocument document, int selectionStart, int selectionLength)
  {
    jetDocumentManager.selectAndReveal(document, selectionStart, selectionLength);
  }

  void selectAndReveal(final JETTextSelectionNavigationLocation navigationLocation, final int selectionStart, final int selectionLength)
  {
    IDocument document = jetDocumentManager.setDocumentID(navigationLocation.getDocumentID());
    if (document != null)
    {
      navigationLocation.restoreDocument(this, document);
      selectAndReveal(selectionStart, selectionLength);
      selectionSynchronizer.sync(getSourceViewer());
    }
    else
    {
      pendingUntilDocumentsAvailable = new Runnable()
        {
          public void run()
          {
            selectAndReveal(navigationLocation, selectionStart, selectionLength);
          }
        };
    }
  }

  void selectAndReveal(final IEditorInput editorInput, final int selectionStart, final int selectionLength)
  {
    String documentID = jetDocumentManager.getDocumentID(editorInput);
    if (documentID != null)
    {
      jetDocumentManager.setDocumentID(documentID);
      selectAndReveal(selectionStart, selectionLength);
      selectionSynchronizer.sync(getSourceViewer());
    }
    else
    {
      pendingUntilDocumentsAvailable = new Runnable()
        {
          public void run()
          {
            selectAndReveal(editorInput, selectionStart, selectionLength);
          }
        };
    }
  }

  @Override
  protected void selectAndReveal(int selectionStart, int selectionLength, int revealStart, int revealLength)
  {
    super.selectAndReveal(selectionStart, selectionLength, revealStart, revealLength);
    invalidateVisibleTextPresentation(false);
  }

  @Override
  public Saveable[] getSaveables()
  {
    return jetDocumentManager.getSaveables();
  }

  @Override
  public boolean isDirty()
  {
    return jetDocumentManager != null && jetDocumentManager.isDirty();
  }

  @Override
  public boolean isEditable()
  {
    return jetDocumentManager.isEditable();
  }

  @Override
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public Object getAdapter(Class adapter)
  {
    if (adapter.equals(IContentOutlinePage.class))
    {
      return getContentOutlinePage();
    }
    else if (adapter.equals(IShowInSource.class))
    {
      return new IShowInSource()
        {
          public ShowInContext getShowInContext()
          {
            return new ShowInContext(jetDocumentManager.getEditorInput(), getSelectionProvider().getSelection());
          }
        };
    }
    else
    {
      return super.getAdapter(adapter);
    }
  }

  JETContentOutlinePage getContentOutlinePage()
  {
    if (contentOutlinePage == null)
    {
      contentOutlinePage = new JETContentOutlinePage(this);
    }
    return contentOutlinePage;
  }

  JETBracketMatcher getJetBracketMatcher()
  {
    return jetBracketMatcher;
  }

  @Override
  protected void configureSourceViewerDecorationSupport(SourceViewerDecorationSupport support)
  {
    support.setCharacterPairMatcher(jetBracketMatcher);
    support.setMatchingCharacterPainterPreferenceKeys("matchingBrackets", "matchingBracketColor");
    super.configureSourceViewerDecorationSupport(support);
  }

  @Override
  protected void initializeKeyBindingScopes()
  {
    setKeyBindingScopes(new String []{ "org.eclipse.emf.codegen.ui.jetEditorScope" }); //$NON-NLS-1$
  }

  IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks)
  {
    List<IHyperlink> hyperlinks = new ArrayList<IHyperlink>();
    JETCompilationUnit compilerResult = getCompilationUnit();
    if (compilerResult != null)
    {
      URI templateURI = toPlatformResourceURI(getEditorInput());
      if (templateURI != null)
      {
        JETItem leafJETItem = compilerResult.getJETItem(getFileID(), region.getOffset(), true);
        if (leafJETItem != null)
        {
          JETItem rootJETItem = leafJETItem.getRoot();
          if (rootJETItem instanceof JETDirectiveItem)
          {
            JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)rootJETItem;
            String directiveName = jetDirectiveItem.getNameItem().getText();
            if ("include".equals(directiveName))
            {
              Object data = jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE);
              if (data != null && Boolean.TRUE.equals(jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE_SUCCESS)))
              {
                JETAttributeItem fileAttribute = jetDirectiveItem.getAttribute("file");
                JETItem valueItem = fileAttribute.getValueToken().getValueItem();
                hyperlinks.add(new JETHyperLink(this, toRegion(valueItem), (Integer)jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE_FILE_ID), (String)data));
              }
            }
            else if ("jet".equals(directiveName))
            {
              JETAttributeItem skeletonAttribute = jetDirectiveItem.getAttribute("skeleton");
              if (skeletonAttribute != null && skeletonAttribute.isAncestor(leafJETItem))
              {
                Object data = jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_SKELETON);
                if (data != null)
                {
                  JETItem valueItem = skeletonAttribute.getValueToken().getValueItem();
                  hyperlinks.add(new JETHyperLink(this, toRegion(valueItem), -1, (String)data));
                }
              }
              JETAttributeItem importsAttribute = jetDirectiveItem.getAttribute("imports");
              if (importsAttribute != null && importsAttribute.isAncestor(leafJETItem) && leafJETItem instanceof JETValueElementItem)
              {
                detectedJavaHyperlinks(hyperlinks, compilerResult, region, canShowMultipleHyperlinks);
              }
            }
            else if ("start".equals(directiveName) || "end".equals(directiveName))
            {
              JETDirectiveItem otherEndItem = (JETDirectiveItem)jetDirectiveItem.getData(JETDirectiveItem.SECTION_OTHER_END);
              if (otherEndItem != null)
              {
                hyperlinks.add(new JETNavigationHyperLink(this, toRegion(jetDirectiveItem.getNameItem()), toRegion(((JETDirectiveItem)otherEndItem).getNameItem())));
              }
            }
          }
          else if (rootJETItem instanceof JETScriptletItem || rootJETItem instanceof JETExpressionItem)
          {
            detectedJavaHyperlinks(hyperlinks, compilerResult, region, canShowMultipleHyperlinks);
          }
        }
      }
    }

    return hyperlinks.isEmpty() ? null : hyperlinks.toArray(new IHyperlink [hyperlinks.size()]);
  }

  void detectedJavaHyperlinks(List<IHyperlink> hyperlinks, JETCompilationUnit compilerResult, IRegion region, boolean canShowMultipleHyperlinks)
  {
    int fileID = getFileID();
    int[] correspondingJavaPoint = compilerResult.getCorrespondingJavaPoint(fileID, region.getOffset(), 0);
    if (correspondingJavaPoint != null)
    {
      javaEditor.selectAndReveal(correspondingJavaPoint[0], 0);
      ISourceViewer javaSourceViewer = javaEditor.getJavaSourceViewer();
      StyledText textWidget = javaSourceViewer.getTextWidget();
      Rectangle bounds = textWidget.getCaret().getBounds();
      textWidget.redraw(bounds.x, bounds.y, bounds.width, bounds.height, false);
      IHyperlinkDetector[] hyperlinkDetectors = javaEditor.getHyperlinkDetectors();
      if (hyperlinkDetectors != null)
      {
        for (IHyperlinkDetector javaHyperlinkDetector : hyperlinkDetectors)
        {
          IHyperlink[] javaHyperlinks = javaHyperlinkDetector.detectHyperlinks(javaSourceViewer, new Region(correspondingJavaPoint[0], 0), canShowMultipleHyperlinks);
          if (javaHyperlinks != null)
          {
            for (IHyperlink javaHyperlink : javaHyperlinks)
            {
              if (!(javaHyperlink instanceof JETHyperLink))
              {
                IRegion hyperlinkRegion = javaHyperlink.getHyperlinkRegion();
                int[] correspondingTemplatePoint = compilerResult.getCorrespondingTemplatePoint(fileID, hyperlinkRegion.getOffset(), hyperlinkRegion.getLength());
                if (correspondingTemplatePoint != null)
                {
                  hyperlinks.add(new JavaHyperLink(this, new Region(correspondingTemplatePoint[0], correspondingTemplatePoint[1]), javaHyperlink));
                }
              }
            }
          }
        }
      }
    }
  }

  void setTokenData(int[] styleRangeOffsets, JETToken[] jetTokens)
  {
    this.styleRangeOffsets = styleRangeOffsets;
    this.jetTokens = jetTokens;
  }

  JETToken getTokenAtSelection(int relativeOffsetFromSelection)
  {
    Point selectedRange = getSourceViewer().getSelectedRange();
    return getTokenAt(selectedRange.x + relativeOffsetFromSelection);
  }

  JETToken getTokenAt(int offset)
  {
    ISourceViewer sourceViewer = getSourceViewer();
    StyledText textWidget = sourceViewer.getTextWidget();
    int charCount = textWidget.getCharCount();
    if (charCount != 0)
    {
      JETTokenRegion tokenRegion = getTokenRegionAt(offset);
      if (tokenRegion != null)
      {
        IToken token = tokenRegion.getToken();
        if (token instanceof JETToken)
        {
          return (JETToken)token;
        }
      }
    }

    return JETContentRule.TOKEN;
  }

  Point getTokenRangeAt(int offset)
  {
    JETTokenRegion tokenRegion = getTokenRegionAt(offset);
    if (tokenRegion != null)
    {
      return new Point(tokenRegion.getOffset(), tokenRegion.getLength());
    }
    return new Point(offset, 0);
  }

  JETTokenRegion getTokenRegionAt(int offset)
  {
    ISourceViewer sourceViewer = getSourceViewer();
    StyledText textWidget = sourceViewer.getTextWidget();
    int charCount = textWidget.getCharCount();
    if (charCount > 0)
    {
      int index = Arrays.binarySearch(styleRangeOffsets, offset);
      if (index < 0)
      {
        index = -index - 2;
      }

      if (index + 1 < styleRangeOffsets.length)
      {
        JETTokenRegion jetTokenRegion = new JETTokenRegion(styleRangeOffsets[index], styleRangeOffsets[index + 1] - styleRangeOffsets[index], jetTokens[index]);
        return jetTokenRegion;
      }
    }

    return null;
  }

  void openDialog(String title, IStatus status)
  {
    if (status != null && !status.isOK())
    {
      String message = status.getMessage();
      if (message.length() == 0)
      {
        Throwable exception = status.getException();
        if (exception != null)
        {
          message = exception.getClass().getName();
        }
      }

      switch (status.getSeverity())
      {
        case IStatus.INFO:
        {
          MessageDialog.openInformation(getSite().getShell(), title, message);
          break;
        }
        case IStatus.WARNING:
        {
          MessageDialog.openWarning(getSite().getShell(), title, message);
          break;
        }
        case IStatus.ERROR:
        default:
        {
          MessageDialog.openError(getSite().getShell(), title, message);
          break;
        }
      }
    }
  }

  static class TrackedPosition extends Position
  {
    private static final String CATEGORY = "__jet_" + TrackedPosition.class.hashCode();

    private static final IPositionUpdater POSITION_UPDATER = new PositionUpdater();

    enum Type
    {
      JET, JAVA
    }

    private IDocument document;

    private final Type type;

    private TrackedPosition opposite;

    public TrackedPosition(Type type)
    {
      this.type = type;
    }

    public void setOpposite(TrackedPosition opposite)
    {
      this.opposite = opposite;
      opposite.opposite = this;
    }

    public TrackedPosition getOpposite()
    {
      return opposite;
    }

    public void addToDocument(IDocument document)
    {
      if (this.document != null)
      {
        uninstallFromDocument(document, this, CATEGORY, POSITION_UPDATER);
      }

      this.document = document;

      setOffset(0);
      setLength(0);
      undelete();

      installOnDocument(document, this, CATEGORY, POSITION_UPDATER);
    }

    public void update(JETJavaItem jetJavaItem)
    {
      if (type == Type.JAVA)
      {
        int javaOffset = jetJavaItem.getJavaOffset();
        int javaLength = jetJavaItem.getJavaLength();
        update(javaOffset, javaLength);
      }
      else
      {
        int jetOffset = jetJavaItem.getStartOffset();
        int jetLength = jetJavaItem.getLength();
        update(jetOffset, jetLength);
      }
    }

    public void update(int offset, int length)
    {
      undelete();
      setOffset(offset);
      setLength(length);
    }

    public String getText()
    {
      if (document != null && !isDeleted())
      {
        try
        {
          return document.get(offset, length);
        }
        catch (BadLocationException exception)
        {
        }
      }
      return null;
    }

    public void dispose()
    {
      if (document != null)
      {
        uninstallFromDocument(document, this, CATEGORY, POSITION_UPDATER);
        document = null;
      }

      delete();
    }

    @Override
    public String toString()
    {
      String toString = super.toString();
      return isDeleted() ? toString : toString + " " + JETItem.toString(getText());
    }

    public static class PositionUpdater implements IPositionUpdater
    {
      protected Position position;

      protected int originalPositionLength;

      protected int originalPositionOffset;

      protected int offset;

      protected int length;

      protected String text;

      protected int replaceLength;

      protected IDocument document;

      public PositionUpdater()
      {
      }

      protected String getCategory()
      {
        return CATEGORY;
      }

      protected void adaptToInsert()
      {
        int myStart = position.offset;
        int myEnd2 = position.offset + position.length;
        int myEnd = position.offset + position.length - 1;
        myEnd = Math.max(myStart, myEnd);

        int yourStart = offset;
        int yourEnd = offset + length;

        if (myStart == yourEnd)
        {
          position.offset = offset;
          position.length = myEnd2 - offset + replaceLength;
        }
        else if (myEnd2 == yourStart)
        {
          position.length += replaceLength;
        }
        else if (myEnd >= yourStart)
        {
          if (myStart < yourStart)
          {
            position.length += replaceLength;
          }
          else
          {
            position.offset += replaceLength;
          }
        }
      }

      protected void adaptToRemove()
      {
        int myStart = position.offset;
        int myEnd = position.offset + position.length - 1;
        myEnd = Math.max(myStart, myEnd);

        int yoursStart = offset;
        int yoursEnd = offset + length - 1;
        yoursEnd = Math.max(yoursStart, yoursEnd);

        if (myEnd >= yoursStart)
        {
          if (myStart <= yoursStart)
          {
            if (yoursEnd <= myEnd)
            {
              position.length -= length;
            }
            else
            {
              position.length -= (myEnd - yoursStart + 1);
            }
          }
          else if (yoursStart < myStart)
          {
            if (yoursEnd < myStart)
            {
              position.offset -= length;
            }
            else
            {
              position.offset -= (myStart - yoursStart);
              position.length -= (yoursEnd - myStart + 1);
            }
          }

          // validate position to allowed values
          if (position.offset < 0)
          {
            position.offset = 0;
          }

          if (position.length < 0)
          {
            position.length = 0;
          }
        }
      }

      protected void adaptToReplace()
      {
        if (length > 0 && position.offset <= offset && offset + length <= position.offset + position.length)
        {
          position.length += replaceLength - length;
        }
        else
        {
          if (length > 0)
          {
            adaptToRemove();
          }

          if (replaceLength > 0)
          {
            adaptToInsert();
          }
        }
      }

      protected boolean notDeleted()
      {
        if (offset < position.offset && position.offset + position.length < offset + length)
        {
          position.delete();
          return false;
        }

        return true;
      }

      public void update(DocumentEvent event)
      {
        try
        {
          document = event.getDocument();
          Position[] category = document.getPositions(CATEGORY);
          if (category.length > 0)
          {
            offset = event.getOffset();
            length = event.getLength();
            text = event.getText();
            if (text == null)
            {
              replaceLength = 0;
              text = "";
            }
            else
            {
              replaceLength = text.length();
            }

            for (Position element : category)
            {
              position = element;
              originalPositionOffset = position.offset;
              originalPositionLength = position.length;

              if (notDeleted())
              {
                adaptToReplace();
              }
            }
          }
        }
        catch (BadPositionCategoryException x)
        {
        }
        finally
        {
          document = null;
          text = null;
        }
      }
    }
  }

  static class JETEditorSaveable extends Saveable
  {
    private JETEditor jetEditor;

    private IEditorInput editorInput;

    private IDocument fDocument;

    public JETEditorSaveable(JETEditor jetEditor, IEditorInput editorInput)
    {
      this.jetEditor = jetEditor;
      this.editorInput = editorInput;
    }

    public IEditorInput getEditorInput()
    {
      return editorInput;
    }

    public void disconnectEditor()
    {
      getAdapter(IDocument.class);
      jetEditor = null;
    }

    @Override
    public String getName()
    {
      return editorInput.getName();
    }

    @Override
    public String getToolTipText()
    {
      return editorInput.getToolTipText();
    }

    @Override
    public ImageDescriptor getImageDescriptor()
    {
      return editorInput.getImageDescriptor();
    }

    @Override
    public void doSave(IProgressMonitor monitor) throws CoreException
    {
      jetEditor.doSave(monitor);
    }

    @Override
    public boolean isDirty()
    {
      return jetEditor.getDocumentProvider().canSaveDocument(editorInput);
    }

    @Override
    public int hashCode()
    {
      Object document = getAdapter(IDocument.class);
      return document == null ? 0 : document.hashCode();
    }

    @Override
    public boolean equals(Object that)
    {
      if (this == that)
      {
        return true;
      }

      if (!(that instanceof Saveable))
      {
        return false;
      }

      Object thisDocument = getAdapter(IDocument.class);
      Object thatDocument = ((Saveable)that).getAdapter(IDocument.class);
      return thisDocument == null ? thatDocument == null : thisDocument.equals(thatDocument);
    }

    @Override
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public Object getAdapter(Class adapter)
    {
      if (adapter == IDocument.class)
      {
        if (fDocument == null)
        {
          IDocumentProvider documentProvider = jetEditor.getDocumentProvider();
          if (documentProvider != null)
          {
            fDocument = documentProvider.getDocument(editorInput);
          }
        }
        return fDocument;
      }

      return super.getAdapter(adapter);
    }
  }

  static class JETDocumentManager
  {
    private final JETEditor jetEditor;

    private final Map<IEditorInput, IDocument> managedDocuments = new LinkedHashMap<IEditorInput, IDocument>();

    private final Map<Integer, IDocument> fileIDs = new LinkedHashMap<Integer, IDocument>();

    private final Map<Integer, String> documentIDs = new LinkedHashMap<Integer, String>();

    private final Set<JETEditorSaveable> saveables = new LinkedHashSet<JETEditorSaveable>();

    private final JavaSynchronizer javaSynchronizer;

    private JETDynamicCompilerJob jetDynamicCompilerJob;

    private int currentFileID;

    private IEditorInput currentEditorInput;

    public JETDocumentManager(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
      javaSynchronizer = new JavaSynchronizer(jetEditor);
    }

    public void setEnableJavaSynchronization(boolean enable)
    {
      javaSynchronizer.setEnableJavaSynchronization(enable);
      if (jetDynamicCompilerJob != null)
      {
        jetDynamicCompilerJob.setDisabled(!enable);
      }
    }

    public void initializeDocumentManager()
    {
      jetEditor.getDocumentProvider().addElementStateListener(new IElementStateListener()
        {
          public void elementMoved(Object originalElement, Object movedElement)
          {
          }

          public void elementDirtyStateChanged(Object element, boolean isDirty)
          {
            JETDocumentManager.this.jetEditor.firePropertyChange(PROP_DIRTY);
          }

          public void elementDeleted(Object element)
          {
          }

          public void elementContentReplaced(Object element)
          {
            JETDocumentManager.this.jetEditor.firePropertyChange(PROP_DIRTY);
          }

          public void elementContentAboutToBeReplaced(Object element)
          {
          }
        });

      registerOutlineHandler();
      registerBreadcrumbHandler();

      ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
      IDocument document = jetSourceViewer.getDocument();
      if (document != null)
      {
        registerDocument(currentEditorInput, document, 0, "~root");
      }

      updateDynamicCompilerJob(currentEditorInput);

      registerSaveable(currentEditorInput);
    }

    protected void registerBreadcrumbHandler()
    {
      jetEditor.getBreadcrumbViewer().addOpenListener(new IOpenListener()
        {
          public void open(OpenEvent event)
          {
            handleItemSelection(event.getSelection());
            jetEditor.setFocus();
          }
        });
    }

    protected void registerOutlineHandler()
    {
      jetEditor.getContentOutlinePage().addSelectionChangedListener(new ISelectionChangedListener()
        {
          public void selectionChanged(SelectionChangedEvent event)
          {
            if (jetEditor.getContentOutlinePage().getControl().isFocusControl())
            {
              handleItemSelection(event.getSelection());
            }
          }
        });
    }

    public void performSave(boolean overwrite, IProgressMonitor progressMonitor)
    {
      List<IEditorInput> changedEditorInputs = new ArrayList<IEditorInput>();
      IDocumentProvider provider = jetEditor.getDocumentProvider();
      try
      {
        for (Map.Entry<IEditorInput, IDocument> entry : managedDocuments.entrySet())
        {
          IEditorInput editorInput = entry.getKey();
          IDocument document = entry.getValue();
          if (provider.canSaveDocument(editorInput))
          {
            provider.aboutToChange(editorInput);
            provider.saveDocument(progressMonitor, editorInput, document, overwrite);
            changedEditorInputs.add(editorInput);
          }
        }

        jetEditor.editorSaved();
      }
      catch (CoreException exception)
      {
        IStatus status = exception.getStatus();
        if (status == null || status.getSeverity() != IStatus.CANCEL)
        {
          jetEditor.handleExceptionOnSave(exception, progressMonitor);
        }
      }
      finally
      {
        for (IEditorInput editorInput : changedEditorInputs)
        {
          provider.changed(editorInput);
        }

        refreshBreadcrumbs();
      }

      if (ResourcesPlugin.getWorkspace().isAutoBuilding() && jetDynamicCompilerJob != null)
      {
        Job job = new Job("Wait for build")
          {
            @Override
            protected IStatus run(IProgressMonitor monitor)
            {
              boolean wasInterrupted = false;
              do
              {
                try
                {
                  getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, monitor);
                  jetDynamicCompilerJob.documentChanged(null);
                  break;
                }
                catch (OperationCanceledException exception)
                {
                  break;
                }
                catch (InterruptedException exception)
                {
                  wasInterrupted = true;
                }
              }
              while (wasInterrupted);
              return Status.OK_STATUS;
            }
          };

        job.setSystem(true);
        job.schedule();
      }
    }

    public void performRevert()
    {
      List<IEditorInput> changedEditorInputs = new ArrayList<IEditorInput>();
      IDocumentProvider provider = jetEditor.getDocumentProvider();
      try
      {
        for (IEditorInput editorInput : managedDocuments.keySet())
        {
          if (provider.canSaveDocument(editorInput))
          {
            provider.aboutToChange(editorInput);
            provider.resetDocument(editorInput);
            changedEditorInputs.add(editorInput);
          }
        }
        jetEditor.editorSaved();
      }
      catch (CoreException exception)
      {
        IStatus status = exception.getStatus();
        if (status == null || status.getSeverity() != IStatus.CANCEL)
        {
          Shell shell = jetEditor.getSite().getShell();
          String title = "Problems while reverting to saved state";
          String msg = "Could not revert to saved state.";
          ErrorDialog.openError(shell, title, msg, exception.getStatus());
        }
      }
      finally
      {
        for (IEditorInput editorInput : changedEditorInputs)
        {
          provider.changed(editorInput);
        }

        refreshBreadcrumbs();
      }
    }

    public Saveable[] getSaveables()
    {
      return saveables.toArray(new Saveable [saveables.size()]);
    }

    public int getFileID()
    {
      return currentFileID;
    }

    public String getDocumentID()
    {
      return getDocumentID(currentFileID);
    }

    private String getDocumentID(int fileID)
    {
      return documentIDs.get(fileID);
    }

    public IDocument getDocument(int fileID)
    {
      return fileIDs.get(fileID);
    }

    String getDocumentID(IEditorInput editorInput)
    {
      for (Map.Entry<Integer, String> entry : this.documentIDs.entrySet())
      {
        String documentID = entry.getValue();
        if (editorInput.equals(getEditorInput(documentID)))
        {
          return documentID;
        }
      }
      return null;
    }

    public int getFileID(IDocument document)
    {
      for (Map.Entry<Integer, IDocument> entry : fileIDs.entrySet())
      {
        if (entry.getValue() == document)
        {
          return entry.getKey();
        }
      }
      return -1;
    }

    public IDocument setDocumentID(String documentID)
    {
      for (Map.Entry<Integer, String> entry : documentIDs.entrySet())
      {
        if (entry.getValue().equals(documentID))
        {
          return setFileID(entry.getKey());
        }
      }

      if (documentID != null)
      {
        IEditorInput editorInput = getEditorInput(documentID);
        int fileID = -1;
        while (fileIDs.containsKey(fileID))
        {
          --fileID;
        }
        getRegisteredDocument(editorInput, fileID, documentID);
        return setFileID(fileID);
      }

      return null;
    }

    public void selectAndReveal(IDocument document, int offset, int length)
    {
      ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
      if (jetSourceViewer.getDocument() != document)
      {
        for (Map.Entry<Integer, IDocument> entry : fileIDs.entrySet())
        {
          if (entry.getValue() == document)
          {
            basicSetFileID(entry.getKey());
            break;
          }
        }
      }

      if (!jetSourceViewer.overlapsWithVisibleRegion(offset, length))
      {
        jetSourceViewer.resetVisibleRegion();
      }

      jetSourceViewer.setSelectedRange(offset, length);
      jetSourceViewer.revealRange(offset, length);
    }

    public IDocument setFileID(int fileID)
    {
      IDocument document = basicSetFileID(fileID);

      JETContentOutlinePage.Item selectionForFileID = jetEditor.getContentOutlinePage().getSelectionForDocumentID(getDocumentID(fileID));
      if (selectionForFileID != null)
      {
        jetEditor.getBreadcrumbViewer().setInput(selectionForFileID);
        jetEditor.getContentOutlinePage().setSelection(new StructuredSelection(selectionForFileID), true);
      }

      return document;
    }

    public IEditorInput getEditorInput()
    {
      IEditorInput editorInput = getEditorInput(getDocument(currentFileID));
      return editorInput == null ? jetEditor.getEditorInput() : editorInput;
    }

    protected IEditorInput getEditorInput(IDocument document)
    {
      for (Map.Entry<IEditorInput, IDocument> entry : managedDocuments.entrySet())
      {
        if (entry.getValue() == document)
        {
          return entry.getKey();
        }
      }
      return null;
    }

    protected IEditorInput getEditorInput(int fileID)
    {
      if (fileID == 0)
      {
        return jetEditor.getEditorInput();
      }
      else
      {
        String documentID = documentIDs.get(fileID);
        return getEditorInput(documentID);
      }
    }

    private IEditorInput getEditorInput(String documentID)
    {
      String templateURI = documentID.replaceAll("~[0-9]+$", "");
      return toEditorInput(URI.createURI(templateURI));
    }

    protected IDocument basicSetFileID(int fileID)
    {
      IEditorInput editorInput = getEditorInput(fileID);
      IDocument registeredDocument = getRegisteredDocument(editorInput, fileID, documentIDs.get(fileID));

      ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
      if (registeredDocument != null && registeredDocument != jetSourceViewer.getDocument())
      {
        IAnnotationModel model = jetEditor.getDocumentProvider().getAnnotationModel(editorInput);
        if (model == null)
        {
          model = new AnnotationModel();
        }

        boolean javaEditorInSync = jetEditor.isJavaEditorInSync();
        setDocument(editorInput, registeredDocument, model);
        if (javaEditorInSync)
        {
          jetEditor.setExpectedModificationStamp();
        }

        this.currentFileID = fileID;
        jetEditor.handleFileIDChanged(fileID);

        registerSaveable(editorInput);
        hookDynamicCompilerJob(registeredDocument);
      }
      else if (this.currentFileID != fileID)
      {
        this.currentFileID = fileID;
        jetEditor.handleFileIDChanged(fileID);
      }

      return registeredDocument;
    }

    protected void setDocument(IEditorInput editorInput, IDocument document, IAnnotationModel annotationModel)
    {
      ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
      jetSourceViewer.setDocument(document, annotationModel);
      IDocumentProvider documentProvider = jetEditor.getDocumentProvider();
      if (documentProvider instanceof IDocumentProviderExtension)
      {
        jetSourceViewer.setEditable(!((IDocumentProviderExtension)documentProvider).isReadOnly(editorInput));
      }
    }

    public boolean isEditable()
    {
      IDocumentProviderExtension documentProvider = (IDocumentProviderExtension)jetEditor.getDocumentProvider();
      IDocument document = fileIDs.get(currentFileID);
      IEditorInput editorInput = getEditorInput(document);
      return editorInput != null && !documentProvider.isReadOnly(editorInput);
    }

    public boolean isDirty(int fileID)
    {
      IDocument document = fileIDs.get(fileID);
      IEditorInput editorInput = getEditorInput(document);
      return editorInput != null && jetEditor.getDocumentProvider().canSaveDocument(editorInput);
    }

    public boolean isDirty()
    {
      IDocumentProvider documentProvider = jetEditor.getDocumentProvider();
      if (documentProvider != null)
      {
        for (IEditorInput editorInput : managedDocuments.keySet())
        {
          if (documentProvider.canSaveDocument(editorInput))
          {
            return true;
          }
        }
      }
      return false;
    }

    protected void registerSaveable(IEditorInput editorInput)
    {
      // Equality checking will prevent duplicates.
      // The first one added will not send a life cycle event because that happens automatically when the part is opened.
      JETEditorSaveable saveable = new JETEditorSaveable(jetEditor, editorInput);
      if (saveables.add(saveable) && saveables.size() > 1)
      {
        ISaveablesLifecycleListener listener = (ISaveablesLifecycleListener)jetEditor.getSite().getService(ISaveablesLifecycleListener.class);
        if (listener != null)
        {
          listener.handleLifecycleEvent(new SaveablesLifecycleEvent(jetEditor, SaveablesLifecycleEvent.POST_OPEN, new Saveable []{ saveable }, false));
        }
      }
    }

    public void handleInputChanged(IEditorInput editorInput)
    {
      ISaveablesLifecycleListener listener = (ISaveablesLifecycleListener)jetEditor.getSite().getService(ISaveablesLifecycleListener.class);
      if (listener != null)
      {
        if (!saveables.isEmpty())
        {
          listener.handleLifecycleEvent(new SaveablesLifecycleEvent(jetEditor, SaveablesLifecycleEvent.POST_CLOSE, getSaveables(), false));
          discardSaveables();
        }

        registerSaveable(editorInput);
      }

      this.currentEditorInput = editorInput;

      updateDynamicCompilerJob(editorInput);
    }

    public void dispose()
    {
      if (jetDynamicCompilerJob != null)
      {
        jetDynamicCompilerJob.cancel();
        for (IDocument document : managedDocuments.values())
        {
          unhookDynamicCompilerJob(document);
        }
      }

      IDocumentProvider documentProvider = jetEditor.getDocumentProvider();
      for (IEditorInput editorInput : managedDocuments.keySet())
      {
        // The source viewer will disconnect itself from the editor's current input so skip that one.
        if (!editorInput.equals(this.currentEditorInput))
        {
          documentProvider.disconnect(editorInput);
        }
      }

      discardSaveables();

      for (IDocument document : managedDocuments.values())
      {
        document.removeDocumentListener(javaSynchronizer);
      }

      managedDocuments.clear();
      fileIDs.clear();
      documentIDs.clear();
    }

    protected void discardSaveables()
    {
      for (JETEditorSaveable saveable : saveables)
      {
        saveable.disconnectEditor();
      }

      saveables.clear();
    }

    protected void updateDynamicCompilerJob(IEditorInput input)
    {
      if (jetDynamicCompilerJob != null)
      {
        jetDynamicCompilerJob.cancel();

        for (IDocument document : managedDocuments.values())
        {
          unhookDynamicCompilerJob(document);
        }

        jetDynamicCompilerJob = null;
      }

      IFile file = toFile(input);
      if (file != null)
      {
        jetDynamicCompilerJob = new JETDynamicCompilerJob(jetEditor, file);
        jetDynamicCompilerJob.schedule();

        for (IDocument document : managedDocuments.values())
        {
          hookDynamicCompilerJob(document);
        }
      }
    }

    protected void hookDynamicCompilerJob(IDocument document)
    {
      document.addDocumentListener(jetDynamicCompilerJob);
    }

    protected void unhookDynamicCompilerJob(IDocument document)
    {
      document.removeDocumentListener(jetDynamicCompilerJob);
    }

    protected void handleItemSelection(ISelection selection)
    {
      if (!selection.isEmpty())
      {
        JETContentOutlinePage contentOutlinePage = jetEditor.getContentOutlinePage();
        int fileID = contentOutlinePage.getFileID(selection);
        basicSetFileID(fileID);

        Region region = contentOutlinePage.getRegion(selection);
        if (region != null)
        {
          jetEditor.selectAndReveal(region.getOffset(), region.getLength());
        }

        JETContentOutlinePage.Item selectedItem = contentOutlinePage.getSelectionForDocumentID(getDocumentID(fileID));
        if (selectedItem != null)
        {
          jetEditor.getBreadcrumbViewer().setInput(selectedItem);
          contentOutlinePage.setSelection(new StructuredSelection(selectedItem), true);
        }
      }
    }

    protected IDocument getRegisteredDocument(IEditorInput editorInput, int fileID, String documentID)
    {
      IDocument document = fileIDs.get(fileID);
      if (document == null && editorInput != null)
      {
        IDocumentProvider documentProvider = jetEditor.getDocumentProvider();
        if (!managedDocuments.containsKey(editorInput))
        {
          try
          {
            documentProvider.connect(editorInput);
          }
          catch (CoreException exception)
          {
            CodeGenUIPlugin.getPlugin().log(exception);
          }
        }

        document = documentProvider.getDocument(editorInput);
        if (document != null)
        {
          registerDocument(editorInput, document, fileID, documentID);
        }
      }

      return document;
    }

    protected void registerDocument(IEditorInput editorInput, IDocument document, int fileID, String documentID)
    {
      managedDocuments.put(editorInput, document);
      fileIDs.put(fileID, document);
      documentIDs.put(fileID, documentID);
      document.addDocumentListener(javaSynchronizer);
      jetEditor.getJETPosition().addToDocument(document);
    }

    public void setCompilerResult(JETCompilerResult jetCompilerResult)
    {
      String currentDocumentID = getDocumentID();

      Set<IDocument> orphanDocuments = new LinkedHashSet<IDocument>(fileIDs.values());

      JETCompilationUnit compilationUnit = jetCompilerResult.getCompilationUnit();
      if (compilationUnit != null)
      {
        fileIDs.clear();
        documentIDs.clear();
        int fileID = 0;
        for (String templateURI : compilationUnit.getTemplateURIs())
        {
          String documentID;
          if (fileID == 0)
          {
            documentID = "~root";
            documentIDs.put(0, documentID);
          }
          else
          {
            documentID = templateURI;
            String collision = documentIDs.put(fileID, templateURI);
            for (int count = 1; collision != null; ++count)
            {
              documentIDs.put(fileID, collision);
              documentID = templateURI + "~" + count;
              collision = documentIDs.put(fileID, documentID);
            }
          }

          IDocument document = managedDocuments.get(toEditorInput(URI.createURI(templateURI)));
          if (document != null)
          {
            fileIDs.put(fileID, document);
            if (documentID.equals(currentDocumentID))
            {
              this.currentFileID = fileID;
            }
          }

          ++fileID;
        }

        // Assign orphaned documents negative file IDs.
        orphanDocuments.removeAll(fileIDs.values());
        if (!orphanDocuments.isEmpty())
        {
          fileID = -1;
          for (IDocument orphanDocument : orphanDocuments)
          {
            fileIDs.put(fileID, orphanDocument);

            for (Map.Entry<IEditorInput, IDocument> entry : managedDocuments.entrySet())
            {
              if (entry.getValue() == orphanDocument)
              {
                URI templateURI = toURI(entry.getKey());
                documentIDs.put(fileID, templateURI.toString());
                break;
              }
            }

            --fileID;
          }
        }
      }

      JETContentOutlinePage contentOutlinePage = jetEditor.getContentOutlinePage();
      contentOutlinePage.setCompilerResult(jetCompilerResult, documentIDs);

      refreshBreadcrumbs();
    }

    private void refreshBreadcrumbs()
    {
      JETBreadcrumbViewer breadcrumbViewer = jetEditor.getBreadcrumbViewer();
      JETContentOutlinePage.Item currentInput = (JETContentOutlinePage.Item)breadcrumbViewer.getInput();
      JETContentOutlinePage.Item newCurrentInput = jetEditor.getContentOutlinePage().getSelectionForDocumentID(getDocumentID(currentFileID));
      if (currentInput != newCurrentInput && newCurrentInput != null)
      {
        breadcrumbViewer.setInput(newCurrentInput);
        jetEditor.getContentOutlinePage().setSelection(new StructuredSelection(newCurrentInput), true);
      }
      else
      {
        breadcrumbViewer.refresh(true);
        for (JETContentOutlinePage.Item item = currentInput; item != null; item = item.getParent())
        {
          breadcrumbViewer.update(item, null);
        }
      }
    }

    static class JavaSynchronizer implements IDocumentListener
    {
      private final JETEditor jetEditor;

      private boolean disabled;

      public JavaSynchronizer(JETEditor jetEditor)
      {
        this.jetEditor = jetEditor;
      }

      public void setEnableJavaSynchronization(boolean enable)
      {
        this.disabled = !enable;
      }

      public void documentChanged(DocumentEvent event)
      {
        if (!disabled)
        {
          int eventOffset = event.getOffset();
          JETTokenRegion tokenRegion = jetEditor.getTokenRegionAt(eventOffset);
          if (tokenRegion != null)
          {
            JETToken token = tokenRegion.getToken();
            if (token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN)
            {
              // Compute the location relative to the start of the Java in the region
              // because as we add characters, we might add beyond the currently corresponding region.
              tokenRegion.shrinkToJava(event.getDocument());
              int tokenJavaStart = tokenRegion.getOffset();
              Position correspondingJavaPosition = jetEditor.getCorrespondingJavaPosition(tokenJavaStart, 0);
              if (correspondingJavaPosition != null)
              {
                try
                {
                  ISourceViewer javaSourceViewer = jetEditor.getJavaSourceViewer();
                  int javaOffset = correspondingJavaPosition.getOffset() + eventOffset - tokenJavaStart;
                  int eventLength = event.getLength();
                  javaSourceViewer.getDocument().replace(javaOffset, eventLength, event.getText());
                  javaSourceViewer.setSelectedRange(javaOffset + 1 - eventLength, 0);
                }
                catch (BadLocationException exception)
                {
                }
              }
            }
          }
        }
      }

      public void documentAboutToBeChanged(DocumentEvent event)
      {
      }
    }
  }

  static class JETContentOutlinePage extends ContentOutlinePage
  {
    private final ItemManager itemManager = new ItemManager();

    private final LabelProvider labelProvider = new LabelProvider();

    private final ContentProvider contentProvider = new ContentProvider();

    private final ISelectionChangedListener jetSourceViewerSynchronizer = new ISelectionChangedListener()
      {
        public void selectionChanged(SelectionChangedEvent event)
        {
          if (treeViewer != null && !treeViewer.getControl().isFocusControl())
          {
            ITextSelection selection = (ITextSelection)event.getSelection();
            int offset = selection.getOffset();
            JETItem jetItem = jetEditor.getJETItem(offset, false);
            if (jetItem != null)
            {
              Item correspondingItem = itemManager.getRootItem().getCorrespondingItem(jetItem);
              if (correspondingItem != null)
              {
                setSelection(new StructuredSelection(correspondingItem), true);
              }
            }
          }
        }
      };

    private final JETEditor jetEditor;

    private TreeViewer treeViewer;

    public JETContentOutlinePage(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    public StyledCellLabelProvider newLabelProvider()
    {
      return new LabelProvider()
        {
          @Override
          protected StyledString getStyledText(Object element)
          {
            StyledString styledText = super.getStyledText(element);
            if (element instanceof Item)
            {
              Item item = (Item)element;
              if (item.isBreadcumbSurrogate())
              {
                int fileID = itemManager.getFileID(item);
                if (jetEditor.getDocumentManager().isDirty(fileID))
                {
                  StyledString newStyledString = new StyledString();
                  newStyledString.append('*');
                  newStyledString.append(styledText);
                  styledText = newStyledString;
                }

                if (fileID == jetEditor.getFileID())
                {
                  styledText.setStyle(0, styledText.length(), Item.getFontStyler(SWT.BOLD));
                }
              }
            }
            return styledText;
          }
        };
    }

    public ITreeContentProvider getContentProvider()
    {
      return contentProvider;
    }

    public Item getSelectionForDocumentID(String documentID)
    {
      return itemManager.getSelectionForDocumentID(documentID);
    }

    public void setSelection(ISelection selection, boolean reveal)
    {
      if (treeViewer != null && !treeViewer.getControl().isFocusControl())
      {
        treeViewer.setSelection(selection, reveal);
      }
    }

    @Override
    public void createControl(Composite parent)
    {
      super.createControl(parent);
      treeViewer = getTreeViewer();
      treeViewer.setLabelProvider(labelProvider);
      treeViewer.setContentProvider(contentProvider);
      treeViewer.setInput(itemManager.getRootItem());
      jetEditor.getSelectionProvider().addSelectionChangedListener(jetSourceViewerSynchronizer);
      registerToolBarActions();
    }

    @SuppressWarnings("restriction")
    private void registerToolBarActions()
    {
      class ExpandAllAction extends Action
      {
        public ExpandAllAction()
        {
          super("", CodeGenUIPlugin.getPlugin().getImage("full/ctool16/ExpandAll.png"));
          setToolTipText("Expand all");
          setActionDefinitionId(ExpandAllHandler.COMMAND_ID);
        }

        @Override
        public void run()
        {
          try
          {
            treeViewer.getControl().setRedraw(false);
            treeViewer.expandAll();
          }
          finally
          {
            treeViewer.getControl().setRedraw(true);
          }
        }
      }

      IToolBarManager toolBarManager = getSite().getActionBars().getToolBarManager();
      toolBarManager.add(new ExpandAllAction());

      org.eclipse.jdt.internal.ui.actions.CollapseAllAction collapseAllAction = new org.eclipse.jdt.internal.ui.actions.CollapseAllAction(treeViewer);
      collapseAllAction.setActionDefinitionId(CollapseAllHandler.COMMAND_ID);
      toolBarManager.add(collapseAllAction);

    }

    @Override
    public void dispose()
    {
      treeViewer = null;
      ISelectionProvider selectionProvider = jetEditor.getSelectionProvider();
      if (selectionProvider != null)
      {
        selectionProvider.removeSelectionChangedListener(jetSourceViewerSynchronizer);
      }
      super.dispose();
    }

    public void setCompilerResult(JETCompilerResult jetCompilerResult, Map<Integer, String> documentIDs)
    {
      itemManager.setCompilerResult(jetCompilerResult, documentIDs);
      if (treeViewer != null)
      {
        treeViewer.refresh();
      }
    }

    public int getFileID(ISelection selection)
    {
      Item item = getSelectedItem(selection);
      return item == null ? 0 : itemManager.getFileID(item);
    }

    public Item getSelectedItem(ISelection selection)
    {
      IStructuredSelection structuredSelection = (IStructuredSelection)selection;
      return (Item)structuredSelection.getFirstElement();
    }

    protected JETItem getSelectedJETItem(ISelection selection)
    {
      Item selectedItem = getSelectedItem(selection);
      return selectedItem == null ? null : selectedItem.getJETItem();
    }

    public Region getRegion(ISelection selection)
    {
      JETItem selectedJETItem = getSelectedJETItem(selection);
      if (selectedJETItem != null)
      {
        int start = selectedJETItem.getStartOffset();
        int stop = selectedJETItem.getStopOffset();
        return new Region(start, stop - start);
      }
      else
      {
        return null;
      }
    }

    private static class LabelProvider extends StyledCellLabelProvider implements ILabelProvider
    {
      private static final Map<Font, Font[]> FONTS = new HashMap<Font, Font[]>();

      @Override
      public void update(ViewerCell cell)
      {
        Object element = cell.getElement();

        StyledString styledString = getStyledText(element);
        String newText = styledString.toString();

        StyleRange[] oldStyleRanges = cell.getStyleRanges();
        StyleRange[] newStyleRanges = isOwnerDrawEnabled() ? styledString.getStyleRanges() : null;

        if (!Arrays.equals(oldStyleRanges, newStyleRanges))
        {
          cell.setStyleRanges(newStyleRanges);
          if (cell.getText().equals(newText))
          {
            cell.setText("");
          }
        }

        cell.setText(newText);
        cell.setImage(getImage(element));

        super.update(cell);
      }

      private FontData[] getFontData(int style)
      {
        FontData[] fontDatas = getViewer().getControl().getFont().getFontData();
        for (int i = 0; i < fontDatas.length; i++)
        {
          fontDatas[i].setStyle(style);
        }
        return fontDatas;
      }

      private Font getFont(int fontStyle)
      {
        if (fontStyle > 0 && fontStyle <= (SWT.BOLD | SWT.ITALIC))
        {
          Font baseFont = getViewer().getControl().getFont();
          Font[] fonts = FONTS.get(baseFont);
          if (fonts == null)
          {
            fonts = new Font [SWT.BOLD | SWT.ITALIC];
            FONTS.put(baseFont, fonts);
          }

          Font font = fonts[fontStyle - 1];
          if (font == null)
          {
            font = new Font(baseFont.getDevice(), getFontData(fontStyle));
            fonts[fontStyle - 1] = font;
          }

          return font;
        }
        else
        {
          return null;
        }
      }

      @Override
      protected StyleRange prepareStyleRange(StyleRange styleRange, boolean applyColors)
      {
        StyleRange preparedStyledRange = super.prepareStyleRange(styleRange, applyColors);
        preparedStyledRange.font = getFont(styleRange.fontStyle);
        return preparedStyledRange;
      }

      public Image getImage(Object element)
      {
        if (element instanceof Item)
        {
          return ((Item)element).getImage();
        }
        return null;
      }

      protected StyledString getStyledText(Object element)
      {
        if (element instanceof Item)
        {
          return ((Item)element).getStyledText();
        }
        if (element instanceof JETItem)
        {
          return new StyledString(((JETItem)element).getText());
        }

        return new StyledString("Root");
      }

      public String getText(Object element)
      {
        return getStyledText(element).toString();
      }
    }

    private static class ContentProvider implements ITreeContentProvider
    {
      public Object[] getElements(Object inputElement)
      {
        return getChildren(inputElement);
      }

      public Object[] getChildren(Object parentElement)
      {
        return ((Item)parentElement).getChildren().toArray();
      }

      public Object getParent(Object element)
      {
        return ((Item)element).getParent();
      }

      public boolean hasChildren(Object element)
      {
        return getChildren(element).length > 0;
      }

      public void dispose()
      {
      }

      public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
      {
      }
    }

    private static class ItemManager extends Item
    {
      private static final Pattern COMMENT_PATTERN = Pattern.compile("^[^\n\r]*\\[([^\\]\n\r]*)\\]");

      private final HashMap<String, Item> managedItems = new HashMap<String, Item>();

      private final HashMap<String, Integer> documementIDsToFileIDs = new HashMap<String, Integer>();

      public ItemManager()
      {
        super("~top", null, "top");
        Item rootItem = createItem(managedItems, "~root", null, "root");
        rootItem.setParent(this);
        documementIDsToFileIDs.put("~root", 0);
      }

      public Item getRootItem()
      {
        return getChildren().get(0);
      }

      public int getFileID(Item item)
      {
        if (item.jetItem != null)
        {
          return item.jetItem.getFileID();
        }
        else if ("orphan".equals(item.type))
        {
          return documementIDsToFileIDs.get(item.signature.substring(0, item.signature.lastIndexOf("~orphan")));
        }
        else
        {
          return 0;
        }
      }

      public Item getSelectionForDocumentID(String documentID)
      {
        Item result = managedItems.get(documentID + "~content");
        if (result == null)
        {
          result = managedItems.get(documentID + "~orphan");
          if (result == null)
          {
            result = managedItems.get(documentID);
          }
        }
        return result;
      }

      public void setCompilerResult(JETCompilerResult comilerResult, Map<Integer, String> documentIDs)
      {
        JETCompilationUnit compilerResult = comilerResult.getCompilationUnit();
        if (compilerResult != null)
        {
          Item newTopItem = createItems(compilerResult, documentIDs);
          reconcile(newTopItem);
          handleProblems(comilerResult);
        }
      }

      @Override
      protected void reconcile(Item newItem)
      {
        super.reconcile(newItem);
        managedItems.clear();
        rebuildMap(managedItems);
      }

      private Item createTopItem(Map<String, Item> managedItems)
      {
        Item topItem = createItem(managedItems, "~top", null, "top");
        Item rootItem = createItem(managedItems, "~root", null, "root");
        rootItem.setParent(topItem);
        return topItem;
      }

      protected Item createItems(JETCompilationUnit compilerResult, Map<Integer, String> documentIDs)
      {
        documementIDsToFileIDs.clear();

        Map<String, Item> newManagedItems = new HashMap<String, Item>();
        Item newTopItem = createTopItem(newManagedItems);
        Item newRootItem = newTopItem.getChildren().get(0);
        List<Item> items = new ArrayList<Item>();
        List<JETItem> jetItems = compilerResult.getItems();
        if (!jetItems.isEmpty())
        {
          newRootItem.setJetItem(jetItems.get(0));
          List<Item> resolvedIncludeSuccessItems = new ArrayList<Item>();
          List<Item> flatContentItems = new ArrayList<Item>();
          for (JETItem jetItem : jetItems)
          {
            if (jetItem instanceof JETDirectiveItem)
            {
              JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetItem;
              JETSkeleton skeleton = (JETSkeleton)jetDirectiveItem.getData(JETDirectiveItem.SKELETON);
              if (skeleton != null)
              {
                if (jetDirectiveItem.getLength() != 0)
                {
                  String qualifiedClassName = skeleton.getQualifiedClassName();
                  Item directiveItem = createItem(newManagedItems, qualifiedClassName, jetItem, "jet");
                  directiveItem.setParent(newRootItem);
                  items.add(directiveItem);
                }
              }
              else
              {
                String resolvedInclude = (String)jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE);
                if (resolvedInclude != null)
                {
                  Item includeItem = createItem(newManagedItems, resolvedInclude, jetItem, "include");
                  items.add(includeItem);
                  includeItem.setParent(newRootItem);
                  if (Boolean.TRUE.equals(jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE_SUCCESS)))
                  {
                    resolvedIncludeSuccessItems.add(includeItem);

                    JETItem contentStartItem = (JETItem)jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE_START);
                    Item item = createItem(newManagedItems, documentIDs.get(contentStartItem.getFileID()) + "~content", contentStartItem, "content");
                    item.setParent(includeItem);
                    flatContentItems.add(item);
                  }
                }
              }
            }
            else if (jetItem instanceof JETCommentItem)
            {
              Matcher matcher = COMMENT_PATTERN.matcher(jetItem.getText());
              if (matcher.find())
              {
                String signature = matcher.group(1);
                Item commentItem = createItem(newManagedItems, signature + "~comment", jetItem, "comment");
                items.add(commentItem);
                commentItem.setParent(newRootItem);
              }
            }
          }

          List<Item> originalItems = new ArrayList<Item>(items);
          List<Item> rootItems = refactorIncludes(items, jetItems, newManagedItems);
          refactorInclusion(resolvedIncludeSuccessItems, originalItems, rootItems);

          for (Item item : flatContentItems)
          {
            int fileID = item.getJETItem().getFileID();
            Item indexItem = createItem(newManagedItems, documentIDs.get(fileID) + "~root", item.getJETItem(), "root");
            indexItem.setParent(newRootItem.getParent());
          }

          for (Map.Entry<Integer, String> entry : documentIDs.entrySet())
          {
            int fileID = entry.getKey();
            String documentID = entry.getValue();
            documementIDsToFileIDs.put(documentID, fileID);
            if (fileID < 0)
            {
              Item indexItem = createItem(newManagedItems, documentID + "~orphan", null, "orphan");
              indexItem.setParent(newRootItem.getParent());
            }
          }
        }

        return newTopItem;
      }

      private void refactorInclusion(List<Item> resolvedIncludeSuccessItems, List<Item> items, List<Item> rootItems)
      {
        for (Item item : items)
        {
          JETItem jetItem = item.getJETItem();
          int fileID = jetItem.getFileID();
          if (fileID != 0)
          {
            if (item.getParent().getJETItem().getFileID() != fileID)
            {
              Item inclusionItem = resolvedIncludeSuccessItems.get(fileID - 1);
              item.setParent(inclusionItem);
              rootItems.remove(item);
            }
          }
        }
      }

      private List<Item> refactorIncludes(List<Item> items, List<JETItem> jetItems, Map<String, Item> managedItems)
      {
        List<Item> result = new ArrayList<Item>();
        while (!items.isEmpty())
        {
          Item item = items.remove(0);
          captureChildren(item, items, jetItems, managedItems);
          result.add(item);
        }
        return result;
      }

      private void captureChildren(Item item, List<Item> remainingItems, List<JETItem> jetItems, Map<String, Item> managedItems)
      {
        JETItem jetItem = item.getJETItem();
        if (jetItem instanceof JETDirectiveItem)
        {
          JETDirectiveItem parentJETItem = (JETDirectiveItem)jetItem;
          JETDirectiveItem start = (JETDirectiveItem)parentJETItem.getData(JETDirectiveItem.SECTION_START);
          JETDirectiveItem end = (JETDirectiveItem)parentJETItem.getData(JETDirectiveItem.SECTION_END);
          if (start != null && end != null)
          {
            String signature = item.getSignature();
            createItem(managedItems, signature + "~start", start, "start").setParent(item);

            int startIndex = jetItems.indexOf(start) + 1;
            int endIndex = jetItems.indexOf(end) - 1;
            for (int i = startIndex; i <= endIndex; ++i)
            {
              JETItem jetChildItem = jetItems.get(i);
              if (jetChildItem instanceof JETDirectiveItem || jetChildItem instanceof JETCommentItem)
              {
                for (Item managedItem : managedItems.values())
                {
                  if (managedItem.getJETItem() == jetChildItem && remainingItems.remove(managedItem))
                  {
                    // Recursively capture the children of nested includes.
                    managedItem.setParent(item);
                    captureChildren(managedItem, remainingItems, jetItems, managedItems);
                    break;
                  }
                }
              }
            }

            createItem(managedItems, signature + "~end", end, "end").setParent(item);
          }
        }
      }

      private Item createItem(Map<String, Item> managedItems, String signature, JETItem jetItem, String type)
      {
        String uniqueSignature = signature;
        for (Item item = managedItems.get(uniqueSignature); item != null; item = managedItems.get(uniqueSignature))
        {
          uniqueSignature += "_";
        }

        Item item = new Item(uniqueSignature, jetItem, type);
        managedItems.put(uniqueSignature, item);
        return item;
      }
    }

    private static class Item
    {
      private static final Map<String, Image> IMAGES = new HashMap<String, Image>();

      private static final Map<String, Image> ERROR_IMAGES = new HashMap<String, Image>();

      private static final Map<String, Image> WARNING_IMAGES = new HashMap<String, Image>();

      private static final Map<String, Image> INFO_IMAGES = new HashMap<String, Image>();

      private static final Map<Integer, Map<String, Image>> ALL_IMAGES = new HashMap<Integer, Map<String, Image>>();

      static
      {
        CodeGenUIPlugin plugin = CodeGenUIPlugin.getPlugin();
        IMAGES.put("start", plugin.getActualImage("full/obj16/DirectiveStart"));
        IMAGES.put("end", plugin.getActualImage("full/obj16/DirectiveEnd"));
        IMAGES.put("include", plugin.getActualImage("full/obj16/DirectiveInclude"));
        IMAGES.put("jet", plugin.getActualImage("full/obj16/JET"));
        IMAGES.put("skeleton", plugin.getActualImage("full/obj16/Skeleton"));
        IMAGES.put("nlstring", plugin.getActualImage("full/obj16/NLString"));
        IMAGES.put("comment", plugin.getActualImage("full/obj16/Comment.png"));

        Image content = plugin.getActualImage("full/obj16/IncludeContent");
        IMAGES.put("content", content);
        IMAGES.put("root", content);
        IMAGES.put("orphan", content);

        org.eclipse.jdt.ui.ISharedImages sharedImages = JavaUI.getSharedImages();
        IMAGES.put("package", sharedImages.getImage(org.eclipse.jdt.ui.ISharedImages.IMG_OBJS_PACKAGE));
        IMAGES.put("class", sharedImages.getImage(org.eclipse.jdt.ui.ISharedImages.IMG_OBJS_CLASS));
        IMAGES.put("import", sharedImages.getImage(org.eclipse.jdt.ui.ISharedImages.IMG_OBJS_IMPDECL));

        Point size = new Point(16, 16);
        for (Map.Entry<String, Image> entry : IMAGES.entrySet())
        {
          // It should use JavaElementImageDescriptor.WARNING but that's not available in Helios.
          int info = JavaElementImageDescriptor.WARNING;
          try
          {
            info = (Integer)JavaElementImageDescriptor.class.getField("INFO").get(null);
          }
          catch (Exception exception)
          {
            // Ignore;
          }

          Image image = new JavaElementImageDescriptor(ImageDescriptor.createFromImage(entry.getValue()), info, size).createImage();
          INFO_IMAGES.put(entry.getKey(), image);
        }

        for (Map.Entry<String, Image> entry : IMAGES.entrySet())
        {
          Image image = new JavaElementImageDescriptor(ImageDescriptor.createFromImage(entry.getValue()), JavaElementImageDescriptor.WARNING, size).createImage();
          WARNING_IMAGES.put(entry.getKey(), image);
        }

        for (Map.Entry<String, Image> entry : IMAGES.entrySet())
        {
          Image image = new JavaElementImageDescriptor(ImageDescriptor.createFromImage(entry.getValue()), JavaElementImageDescriptor.ERROR, size).createImage();
          ERROR_IMAGES.put(entry.getKey(), image);
        }

        ALL_IMAGES.put(-1, IMAGES);
        ALL_IMAGES.put(IMarker.SEVERITY_INFO, INFO_IMAGES);
        ALL_IMAGES.put(IMarker.SEVERITY_WARNING, WARNING_IMAGES);
        ALL_IMAGES.put(IMarker.SEVERITY_ERROR, ERROR_IMAGES);
      }

      private static final Styler STRIKE_OUT_STYLER = new Styler()
        {
          @Override
          public void applyStyles(TextStyle textStyle)
          {
            textStyle.strikeout = true;
          }
        };

      private static final Styler[] FONT_STYLERS = new Styler [SWT.BOLD | SWT.ITALIC];

      private static final Styler getFontStyler(final int fontStyle)
      {
        if (fontStyle > 0 && fontStyle < (SWT.BOLD | SWT.ITALIC))
        {
          Styler styler = FONT_STYLERS[fontStyle];
          if (styler == null)
          {
            styler = new Styler()
              {
                @Override
                public void applyStyles(TextStyle textStyle)
                {
                  ((StyleRange)textStyle).fontStyle = fontStyle;
                }
              };
            FONT_STYLERS[fontStyle] = styler;
          }
          return styler;
        }
        else
        {
          return null;
        }
      }

      private final List<Item> children = new ArrayList<Item>();

      private final String type;

      private final String signature;

      private Item parent;

      private JETItem jetItem;

      private int problemSeverity = -1;

      public Item(String signature, JETItem jetItem, String type)
      {
        this.signature = signature;
        this.jetItem = jetItem;
        this.type = type == null ? getDirectiveType(jetItem) : type;

        if ("jet".equals(type))
        {
          createJETChildren();
        }
      }

      public Item getCorrespondingItem(JETItem jetItem)
      {
        for (Item child : children)
        {
          Item result = child.getCorrespondingItem(jetItem);
          if (result != null)
          {
            return result;
          }
        }

        return this.jetItem == jetItem ? this : null;
      }

      public boolean isBreadcumbSurrogate()
      {
        return "root".equals(type) || "orphan".equals(type);
      }

      public int handleProblems(JETCompilerResult compilerResult)
      {
        int maxSeverity = -1;
        for (Item child : children)
        {
          maxSeverity = Math.max(maxSeverity, child.handleProblems(compilerResult));
        }

        if ("class".equals(type))
        {
          int overallSeverity = getJavaProblemSeverity(compilerResult.getJavaProblems());
          maxSeverity = Math.max(maxSeverity, overallSeverity);
        }
        else if ("content".equals(type) || "root".equals(type))
        {
          int overallSeverity = getProblemSeverity(compilerResult.getProblems(jetItem.getFileID()));
          maxSeverity = Math.max(maxSeverity, overallSeverity);
        }
        else if ("jet".equals(type) && Boolean.TRUE.equals(((JETDirectiveItem)jetItem).getData(JETDirectiveItem.MISSING_JET_DIRECTIVE)))
        {
          maxSeverity = IMarker.SEVERITY_ERROR;
        }
        else if ("orphan".equals(type))
        {
          maxSeverity = IMarker.SEVERITY_WARNING;
        }
        else if (jetItem != null)
        {
          int localSeverity = getProblemSeverity(compilerResult.getProblem(jetItem));
          maxSeverity = Math.max(maxSeverity, localSeverity);
        }

        this.problemSeverity = maxSeverity;

        return maxSeverity;
      }

      private static final Method INFO_METHOD;

      static
      {
        Method infoMethod = null;
        try
        {
          infoMethod = IProblem.class.getMethod("isInfo");
        }
        catch (Exception exception)
        {
          // Ignore.
        }
        INFO_METHOD = infoMethod;
      }

      private static boolean isInfo(IProblem problem)
      {
        try
        {
          return (Boolean)INFO_METHOD.invoke(problem);
        }
        catch (Exception exception)
        {
          return false;
        }
      }

      private int getJavaProblemSeverity(List<IProblem> problems)
      {
        int result = -1;
        for (IProblem problem : problems)
        {
          int severity = isInfo(problem) ? IMarker.SEVERITY_INFO : problem.isWarning() ? IMarker.SEVERITY_WARNING : problem.isError() ? IMarker.SEVERITY_ERROR : -1;
          result = Math.max(result, severity);
          if (result == IMarker.SEVERITY_ERROR)
          {
            return IMarker.SEVERITY_ERROR;
          }
        }
        return result;
      }

      private int getProblemSeverity(List<JETProblemAnnotation> problems)
      {
        int result = -1;
        for (JETProblemAnnotation problem : problems)
        {
          result = Math.max(result, problem.getSeverity());
          if (result == IMarker.SEVERITY_ERROR)
          {
            return IMarker.SEVERITY_ERROR;
          }
        }
        return result;
      }

      protected void rebuildMap(HashMap<String, Item> managedItems)
      {
        managedItems.put(signature, this);
        for (Item child : children)
        {
          child.rebuildMap(managedItems);
        }
      }

      protected void reconcile(Item newItem)
      {
        // Remove all the existing children.
        Item[] existingChildren = children.toArray(new Item [children.size()]);
        Map<String, Item> signatures = new HashMap<String, Item>();
        for (Item child : existingChildren)
        {
          child.setParent(null);
          signatures.put(child.getSignature(), child);
        }

        Item[] newChildren = newItem.children.toArray(new Item [newItem.children.size()]);
        for (Item newChild : newChildren)
        {
          Item correspondingOldChild = signatures.get(newChild.getSignature());
          if (correspondingOldChild == null)
          {
            // Add the new child.
            newChild.setParent(this);
          }
          else
          {
            // Add the old child back in, transfer the new JET item and recursively reconcile its children.
            correspondingOldChild.setParent(this);
            correspondingOldChild.jetItem = newChild.jetItem;
            correspondingOldChild.reconcile(newChild);
          }
        }
      }

      private void createJETChildren()
      {
        JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetItem;
        if (!Boolean.TRUE.equals(jetDirectiveItem.getData(JETDirectiveItem.DUPLICATE_JET_DIRECTIVE)))
        {
          JETAttributeItem packageAttributeItem = jetDirectiveItem.getAttribute("package");
          Item rootItem = this;
          if (packageAttributeItem != null)
          {
            JETValueItem packageValueItem = packageAttributeItem.getValueToken().getValueItem();
            Item packageItem = new Item(signature + "~package", packageValueItem, "package");
            packageItem.setParent(this);
            rootItem = packageItem;
          }

          JETAttributeItem classAttributeItem = jetDirectiveItem.getAttribute("class");
          if (classAttributeItem != null)
          {
            JETValueItem classValueItem = classAttributeItem.getValueToken().getValueItem();
            Item classItem = new Item(rootItem.getSignature() + "~class", classValueItem, "class");
            classItem.setParent(rootItem);
            rootItem = classItem;
          }

          JETAttributeItem importsAttribute = jetDirectiveItem.getAttribute("imports");
          if (importsAttribute != null)
          {
            for (JETValueElementItem jetImportItem : importsAttribute.getValueToken().getValueItem().getElements())
            {
              String importValue = jetImportItem.getValue();
              Item importItem = new Item(rootItem.getSignature() + importValue + "~import", jetImportItem, "import");
              importItem.setParent(rootItem);
            }
          }

          JETAttributeItem skeletonAttribute = jetDirectiveItem.getAttribute("skeleton");
          if (skeletonAttribute != null)
          {
            JETValueItem skeletonValueItem = skeletonAttribute.getValueToken().getValueItem();
            Item skeletonItem = new Item(signature + "~skeleton", skeletonValueItem, "skeleton");
            skeletonItem.setParent(this);
          }

          JETAttributeItem nlString = jetDirectiveItem.getAttribute("nlString");
          if (nlString != null)
          {
            JETValueItem nlStringValue = nlString.getValueToken().getValueItem();
            Item skeletonItem = new Item(signature + "~nlstring", nlStringValue, "nlstring");
            skeletonItem.setParent(this);
          }
        }
      }

      protected void setJetItem(JETItem jetItem)
      {
        this.jetItem = jetItem;
      }

      public Item getParent()
      {
        return parent;
      }

      protected void setParent(Item parent)
      {
        if (this.parent != null)
        {
          this.parent.children.remove(this);
        }

        this.parent = parent;
        if (parent != null)
        {
          parent.children.add(this);
        }
      }

      public String getSignature()
      {
        return signature;
      }

      public JETItem getJETItem()
      {
        return jetItem;
      }

      public Image getImage()
      {
        return ALL_IMAGES.get(problemSeverity).get(type);
      }

      public List<Item> getChildren()
      {
        return children;
      }

      public StyledString getStyledText()
      {
        if ("jet".equals(type))
        {
          JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetItem;
          JETSkeleton skeleton = (JETSkeleton)jetDirectiveItem.getData(JETDirectiveItem.SKELETON);
          String className = skeleton.getClassName();
          String packageName = skeleton.getPackageName();
          StyledString result = new StyledString(className);
          if (packageName.length() != 0)
          {
            result.append(" - " + packageName, StyledString.DECORATIONS_STYLER);
          }
          if (Boolean.TRUE.equals(jetDirectiveItem.getData(JETDirectiveItem.DUPLICATE_JET_DIRECTIVE)))
          {
            result.setStyle(0, result.length(), STRIKE_OUT_STYLER);
          }
          return result;
        }
        else if ("include".equals(type))
        {
          JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetItem;
          boolean resolvedIncludeSuccess = Boolean.TRUE.equals(jetDirectiveItem.getData(JETDirectiveItem.RESOLVED_INCLUDE_SUCCESS));
          return new StyledString(
            jetDirectiveItem.getAttribute("file").getValueToken().getValueItem().getText(),
            resolvedIncludeSuccess
              ? jetDirectiveItem.isSkipped() ? STRIKE_OUT_STYLER : getFontStyler(SWT.BOLD) : getChildren().isEmpty() ? STRIKE_OUT_STYLER : getFontStyler(SWT.ITALIC));
        }
        else if ("content".equals(type) || "root".equals(type) || "orphan".equals(type))
        {
          if (jetItem == null && !"orphan".equals(type))
          {
            return new StyledString("Analyzing...");
          }
          else
          {
            JETMark start = jetItem == null ? null : jetItem.getStart();
            URI uri = URI.createURI(start == null ? signature.substring(0, signature.lastIndexOf("~orphan")) : start.getResolvedURI());
            String fileName = uri.lastSegment();
            StyledString result = new StyledString(fileName);

            URI baseURI = uri.trimSegments(1);
            String relativeLocation = baseURI.isPlatformResource() ? baseURI.toPlatformString(true) : baseURI.toString();

            if (start != null)
            {
              while (start.getParentMark() != null)
              {
                start = start.getParentMark();
              }
            }

            URI rootURI = URI.createURI(start == null ? parent.getChildren().get(0).jetItem.getStart().getResolvedURI() : start.getResolvedURI());
            if (rootURI.isPlatformResource() && uri.isPlatformResource())
            {
              URI deresolvedURI = uri.deresolve(rootURI, true, true, false);
              if (deresolvedURI.segmentCount() > 1 && !"..".equals(deresolvedURI.segment(0)))
              {
                relativeLocation = deresolvedURI.trimSegments(1).toString();
              }
            }

            result.append(" - " + relativeLocation, StyledString.DECORATIONS_STYLER);
            if ("content".equals(type) && ((JETDirectiveItem)parent.jetItem).isSkipped() || "orphan".equals(type))
            {
              result.setStyle(0, result.length(), STRIKE_OUT_STYLER);
            }

            return result;
          }
        }
        else if ("top".equals(type))
        {
          return new StyledString("top");
        }
        else if ("start".equals(type) || "end".equals(type))
        {
          JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetItem;
          return new StyledString(jetItem.getText(), jetDirectiveItem.isSkipped() ? STRIKE_OUT_STYLER : null);
        }
        else if ("comment".equals(type))
        {
          return new StyledString(signature.substring(0, signature.lastIndexOf("~comment")));
        }

        if (jetItem instanceof JETValueItem)
        {
          return new StyledString(((JETValueItem)jetItem).getValue());
        }

        if (jetItem instanceof JETValueElementItem)
        {
          return new StyledString(((JETValueElementItem)jetItem).getValue());
        }

        return new StyledString(jetItem == null ? "" : jetItem.getText());
      }

      private static String getDirectiveType(JETItem jetItem)
      {
        if (jetItem instanceof JETDirectiveItem)
        {
          return ((JETDirectiveItem)jetItem).getNameItem().getText();
        }
        else
        {
          return null;
        }
      }
    }
  }

  static class ViewPortHandler implements IViewportListener, Runnable
  {
    private final JETEditor jetEditor;

    private final StyledText jetStyledText;

    private int topIndex;

    public ViewPortHandler(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
      ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
      jetSourceViewer.addViewportListener(this);
      jetStyledText = jetSourceViewer.getTextWidget();
    }

    public void viewportChanged(int verticalOffset)
    {
      topIndex = jetStyledText.getTopIndex();
      jetStyledText.getDisplay().timerExec(200, this);
    }

    public void run()
    {
      if (!jetStyledText.isDisposed() && topIndex == jetStyledText.getTopIndex())
      {
        jetEditor.invalidateVisibleTextPresentation(false);
      }
    }
  }

  static class JavaHyperLink implements IHyperlink
  {
    private final JETEditor jetEditor;

    private final IRegion region;

    private final IHyperlink javaHyperlink;

    public JavaHyperLink(JETEditor jetEditor, IRegion region, IHyperlink javaHyperlink)
    {
      this.jetEditor = jetEditor;
      this.region = region;
      this.javaHyperlink = javaHyperlink;
    }

    public IRegion getHyperlinkRegion()
    {
      return region;
    }

    public String getTypeLabel()
    {
      return javaHyperlink.getTypeLabel();
    }

    public String getHyperlinkText()
    {
      return javaHyperlink.getHyperlinkText();
    }

    public void open()
    {
      jetEditor.markInNavigationHistory();
      javaHyperlink.open();
    }
  }

  static class JETHyperLink implements IHyperlink
  {
    private final IRegion region;

    private JETEditor jetEditor;

    private final int fileID;

    private final String locationURI;

    public JETHyperLink(JETEditor jetEditor, IRegion region, int fileID, String locationURI)
    {
      this.jetEditor = jetEditor;
      this.region = region;
      this.fileID = fileID;
      this.locationURI = locationURI;
    }

    public IRegion getHyperlinkRegion()
    {
      return region;
    }

    public String getTypeLabel()
    {
      return "Open";
    }

    public String getHyperlinkText()
    {
      URI uri = URI.createURI(locationURI);
      return "Open JET " + (uri.isPlatformResource() ? uri.toPlatformString(true) : uri.toString());
    }

    public void open()
    {
      jetEditor.markInNavigationHistory();
      if (fileID == -1)
      {
        JETEditor.open(jetEditor.getEditorSite(), locationURI);
      }
      else
      {
        jetEditor.getDocumentManager().setFileID(fileID);
        Position correspondingTemplatePoint = jetEditor.getCorrespondingTemplatePosition(region.getOffset(), region.getLength());
        if (correspondingTemplatePoint != null)
        {
          jetEditor.selectAndReveal(correspondingTemplatePoint.offset, correspondingTemplatePoint.length);
        }
        else
        {
          jetEditor.markInNavigationHistory();
        }
      }
    }
  }

  static class JETNavigationHyperLink implements IHyperlink
  {
    protected final JETEditor jetEditor;

    private final IRegion region;

    protected final IRegion targetRegion;

    public JETNavigationHyperLink(JETEditor jetEditor, IRegion region, IRegion targetRegion)
    {
      this.jetEditor = jetEditor;
      this.region = region;
      this.targetRegion = targetRegion;
    }

    public IRegion getHyperlinkRegion()
    {
      return region;
    }

    public String getTypeLabel()
    {
      return "Navigate";
    }

    public String getHyperlinkText()
    {
      return "Navigate in Template";
    }

    public void open()
    {
      jetEditor.markInNavigationHistory();
      jetEditor.selectAndReveal(targetRegion.getOffset(), targetRegion.getLength());
    }
  }

  static class SelectionSynchronizer
  {
    private final JETEditor jetEditor;

    private final JavaEditor javaEditor;

    private final ISourceViewer jetUnderlyingSourceViewer;

    private final ISourceViewer javaUnderlyingSourceViewer;

    private CaretAndSelectionListener jetToJava;

    private CaretAndSelectionListener javaToJET;

    public SelectionSynchronizer(JETEditor jetEditor, final JavaEditor javaEditor)
    {
      this.jetEditor = jetEditor;
      this.javaEditor = javaEditor;

      this.jetUnderlyingSourceViewer = jetEditor.getSourceViewer();
      this.javaUnderlyingSourceViewer = javaEditor.getJavaSourceViewer();

      jetToJava = new CaretAndSelectionListener(jetUnderlyingSourceViewer, javaUnderlyingSourceViewer);
      javaToJET = new CaretAndSelectionListener(javaUnderlyingSourceViewer, jetUnderlyingSourceViewer);
    }

    public void sync(ISourceViewer viewer)
    {
      (viewer == jetUnderlyingSourceViewer ? jetToJava : javaToJET).handle();
    }

    class CaretAndSelectionListener implements CaretListener, SelectionListener
    {
      private final ISourceViewer source;

      private final ISourceViewer target;

      public CaretAndSelectionListener(ISourceViewer source, ISourceViewer target)
      {
        this.source = source;
        this.target = target;
        StyledText textWidget = source.getTextWidget();
        textWidget.addCaretListener(this);
        textWidget.addSelectionListener(this);
      }

      public void widgetSelected(SelectionEvent event)
      {
        if (isEnabled(event))
        {
          if (event.widget == javaUnderlyingSourceViewer.getTextWidget() && javaEditor.isNavigating())
          {
            Point javaSelectedRange = source.getSelectedRange();
            int javaOffset = javaSelectedRange.x;
            int correspondingTemplateFileID = jetEditor.getCorrespondingTemplateFileID(javaOffset);
            if (correspondingTemplateFileID != -1 && correspondingTemplateFileID != jetEditor.getFileID())
            {
              jetEditor.getDocumentManager().setFileID(correspondingTemplateFileID);
            }
          }

          handle();
        }
      }

      public void widgetDefaultSelected(SelectionEvent event)
      {
        if (isEnabled(event))
        {
          handle();
        }
      }

      public void caretMoved(CaretEvent event)
      {
        if (isEnabled(event))
        {
          // A caret move event doesn't generate a selection event if the selection was empty and is also now empty.
          // Furthermore, the queried selection range is stale during the notification, so we must post an event check the range again.
          final StyledText styledText = (StyledText)event.widget;
          if (styledText.getSelectionRange().y == 0)
          {
            event.widget.getDisplay().asyncExec(new Runnable()
              {
                public void run()
                {
                  // If the range is still empty, we need to generate a notification so that the cursors can stay in sync.
                  Point selection = styledText.getSelectionRange();
                  if (selection.y == 0)
                  {
                    Event fakeEvent = new Event();
                    fakeEvent.x = fakeEvent.y = selection.x;
                    styledText.notifyListeners(SWT.Selection, fakeEvent);
                  }
                }
              });
          }
        }
      }

      protected boolean isEnabled(TypedEvent event)
      {
        if (((Control)event.widget).isFocusControl())
        {
          // Don't synchronize anything if the document contents are out of sync with the Java contents.
          return jetEditor.isJavaEditorInSync();
        }
        else
        {
          return event.widget == javaUnderlyingSourceViewer.getTextWidget() && javaEditor.isNavigating();
        }
      }

      protected void handle()
      {
        Point selectedRange = source.getSelectedRange();

        if (source == jetUnderlyingSourceViewer)
        {
          JETItem startItem = jetEditor.getJETItem(selectedRange.x, false);
          JETItem endItem = jetEditor.getJETItem(selectedRange.x + selectedRange.y, false);

          TrackedPosition jetPosition = jetEditor.getJETPosition();
          if (startItem == endItem && startItem instanceof JETJavaItem && !(startItem instanceof JETLiteralItem))
          {
            JETJavaItem jetJavaItem = (JETJavaItem)startItem;
            jetPosition.update(jetJavaItem);
            jetEditor.getJavaPosition().update(jetJavaItem);
          }
          else
          {
            int start = startItem == null ? selectedRange.x : startItem.getStartOffset();
            int end = endItem == null ? startItem == null ? selectedRange.x + selectedRange.y : startItem.getStopOffset() : endItem.getStopOffset();
            int length = end - start;

            if (start != 0 && startItem instanceof JETLiteralItem)
            {
              JETToken token = jetEditor.getTokenAt(start - 1);
              if (token == JETDirectiveRule.TOKEN || token == JETCommentRule.TOKEN || token == JETScriptletRule.TOKEN)
              {
                // These items all consume the line delimiter that immediately follows.
                IDocument document = jetUnderlyingSourceViewer.getDocument();
                try
                {
                  char character = document.getChar(start);
                  if (character == '\n' || character == '\r')
                  {
                    ++start;
                    --length;
                    if (character == '\r' && document.getChar(start) == '\n')
                    {
                      ++start;
                      --length;
                    }
                  }
                }
                catch (BadLocationException exception)
                {
                }
              }
            }

            if (endItem instanceof JETLiteralItem)
            {
              // Always exclude the final line delimiter.
              IDocument document = jetUnderlyingSourceViewer.getDocument();
              try
              {
                char character = document.getChar(start + length);
                if (character == '\n' || character == '\r')
                {
                  --length;
                  if (character == '\n' && document.getChar(start) == '\r')
                  {
                    --length;
                  }
                }
              }
              catch (BadLocationException exception)
              {
              }
            }

            jetPosition.update(start, length);
          }

          jetUnderlyingSourceViewer.setRangeIndication(jetPosition.getOffset(), jetPosition.getLength(), false);
        }

        Position correspondingPoint = source == jetUnderlyingSourceViewer
          ? jetEditor.getCorrespondingJavaPosition(selectedRange.x, selectedRange.y) : jetEditor.getCorrespondingTemplatePosition(selectedRange.x, selectedRange.y);
        if (correspondingPoint != null)
        {
          Position correspondingPointEnd = null;
          for (int i = 0; i < 100 && correspondingPointEnd == null && selectedRange.y > 0; ++i, --selectedRange.y)
          {
            int endOffset = selectedRange.x + selectedRange.y;
            correspondingPointEnd = source == jetUnderlyingSourceViewer
              ? jetEditor.getCorrespondingJavaPosition(endOffset, 0) : jetEditor.getCorrespondingTemplatePosition(endOffset, 0);
          }

          int length = correspondingPointEnd == null ? correspondingPoint.length : correspondingPointEnd.offset + correspondingPointEnd.length - correspondingPoint.offset;
          (target == jetUnderlyingSourceViewer ? jetEditor : javaEditor).selectAndReveal(correspondingPoint.offset, length);

          StyledText textWidget = target.getTextWidget();
          Rectangle bounds = textWidget.getCaret().getBounds();
          textWidget.redraw(bounds.x, bounds.y, bounds.width, bounds.height, false);
        }
      }
    }
  }

  @SuppressWarnings("restriction")
  static class DelegatingTextHover implements IJavaEditorTextHover, ITextHoverExtension, ITextHoverExtension2
  {
    private final org.eclipse.jdt.internal.ui.text.java.hover.JavadocHover javadocHover = new org.eclipse.jdt.internal.ui.text.java.hover.JavadocHover();

    private final JETEditor jetEditor;

    private DefaultTextHover defaultTextHover;

    private ISourceViewer javaTextViewer;

    public DelegatingTextHover(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    public void setEditor(IEditorPart editor)
    {
      javadocHover.setEditor(editor);
      javaTextViewer = ((JavaEditor)editor).getJavaSourceViewer();
      defaultTextHover = new DefaultTextHover(jetEditor.getSourceViewer());
    }

    public IRegion getHoverRegion(ITextViewer textViewer, int offset)
    {
      return defaultTextHover.getHoverRegion(textViewer, offset);
    }

    @SuppressWarnings("deprecation")
    public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion)
    {
      IRegion javaRegion = toJava(hoverRegion);
      return javaRegion == null ? defaultTextHover.getHoverInfo(textViewer, hoverRegion) : javadocHover.getHoverInfo(javaTextViewer, javaRegion);
    }

    public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion)
    {
      IRegion javaRegion = toJava(hoverRegion);
      return javaRegion == null ? null : javadocHover.getHoverInfo2(javaTextViewer, javaRegion);
    }

    public IInformationControlCreator getHoverControlCreator()
    {
      return javadocHover.getHoverControlCreator();
    }

    private IRegion toJava(IRegion templateRegion)
    {
      Position correspondingJavaPoint = jetEditor.getCorrespondingJavaPosition(templateRegion.getOffset(), templateRegion.getLength());
      if (correspondingJavaPoint != null)
      {
        return new Region(correspondingJavaPoint.getOffset(), correspondingJavaPoint.getLength());
      }
      return null;
    }
  }

  static class CompletionProposalDelegate
    implements
      ICompletionProposal,
      ICompletionProposalExtension2,
      ICompletionProposalExtension3,
      ICompletionProposalExtension4,
      ICompletionProposalExtension5,
      ICompletionProposalExtension6
  {
    private final JETEditor jetEditor;

    private final ICompletionProposal delegate;

    private final ITextViewer delegateViewer;

    final IDocument delegateDocument;

    final TrackedPosition javaPosition;

    final TrackedPosition jetPosition;

    public CompletionProposalDelegate(ICompletionProposal delelgate, JETEditor jetEditor)
    {
      this.delegate = delelgate;
      this.jetEditor = jetEditor;
      this.delegateViewer = jetEditor.getJavaSourceViewer();
      this.delegateDocument = delegateViewer.getDocument();
      this.jetPosition = jetEditor.getJETPosition();
      this.javaPosition = jetEditor.getJavaPosition();
    }

    public void apply(IDocument document)
    {
      JavaDocumentTransaction javaDocumentTransaction = new CompletionTransaction(jetEditor);
      javaDocumentTransaction.modify(delegateDocument, new SneakyRunnable()
        {
          @Override
          public void execute() throws Exception
          {
            Method performChangeMethod = null;
            // We do this ugliness because directly applying the proposal will often want to open the Java editor and we definitely don't want that.
            for (Class<?> delegateClass = delegate.getClass(); delegateClass != null; delegateClass = delegateClass.getSuperclass())
            {
              try
              {
                performChangeMethod = delegateClass.getDeclaredMethod("performChange", IEditorPart.class, IDocument.class);
                performChangeMethod.setAccessible(true);
                break;
              }
              catch (Exception exception)
              {
              }
            }

            if (performChangeMethod != null)
            {
              performChangeMethod.invoke(delegate, jetEditor.getJavaEditor(), delegateDocument);
            }
            else
            {
              delegate.apply(delegateDocument);
            }
          }
        });

      jetEditor.openDialog("Proposal Failed", javaDocumentTransaction.getStatus());
    }

    public void apply(ITextViewer viewer, final char trigger, final int stateMask, int offset)
    {
      if (delegate instanceof ICompletionProposalExtension2)
      {
        JavaDocumentTransaction javaDocumentTransaction = new CompletionTransaction(jetEditor);
        javaDocumentTransaction.modify(delegateDocument, new Runnable()
          {
            public void run()
            {
              ((ICompletionProposalExtension2)delegate).apply(delegateViewer, trigger, stateMask, delegateViewer.getSelectedRange().x);
            }
          });

        jetEditor.openDialog("Proposal Failed", javaDocumentTransaction.getStatus());
      }
      else
      {
        apply(delegateDocument);
      }
    }

    public Point getSelection(IDocument document)
    {
      return null;
    }

    public String getAdditionalProposalInfo()
    {
      return delegate.getAdditionalProposalInfo();
    }

    public String getDisplayString()
    {
      return delegate.getDisplayString();
    }

    public Image getImage()
    {
      return delegate.getImage();
    }

    public IContextInformation getContextInformation()
    {
      return delegate.getContextInformation();
    }

    public StyledString getStyledDisplayString()
    {
      return delegate instanceof ICompletionProposalExtension6 ? ((ICompletionProposalExtension6)delegate).getStyledDisplayString() : new StyledString(getDisplayString());
    }

    public Object getAdditionalProposalInfo(IProgressMonitor monitor)
    {
      return delegate instanceof ICompletionProposalExtension5 ? ((ICompletionProposalExtension5)delegate).getAdditionalProposalInfo(monitor) : null;
    }

    public boolean isAutoInsertable()
    {
      return delegate instanceof ICompletionProposalExtension4 && ((ICompletionProposalExtension4)delegate).isAutoInsertable();
    }

    public IInformationControlCreator getInformationControlCreator()
    {
      return delegate instanceof ICompletionProposalExtension3 ? ((ICompletionProposalExtension3)delegate).getInformationControlCreator() : null;
    }

    private int jetToJava(int templateOffset)
    {
      return javaPosition.getOffset() + templateOffset - jetPosition.getOffset();
    }

    public CharSequence getPrefixCompletionText(IDocument document, int completionOffset)
    {
      return delegate instanceof ICompletionProposalExtension3
        ? ((ICompletionProposalExtension3)delegate).getPrefixCompletionText(delegateDocument, jetToJava(completionOffset)) : null;
    }

    public int getPrefixCompletionStart(IDocument document, int completionOffset)
    {
      return delegate instanceof ICompletionProposalExtension3
        ? ((ICompletionProposalExtension3)delegate).getPrefixCompletionStart(delegateDocument, jetToJava(completionOffset)) : null;
    }

    public void selected(ITextViewer viewer, boolean smartToggle)
    {
      if (delegate instanceof ICompletionProposalExtension2)
      {
        ((ICompletionProposalExtension2)delegate).selected(delegateViewer, smartToggle);
      }
    }

    public void unselected(ITextViewer viewer)
    {
      if (delegate instanceof ICompletionProposalExtension2)
      {
        ((ICompletionProposalExtension2)delegate).unselected(delegateViewer);
      }
    }

    public boolean validate(IDocument document, int offset, DocumentEvent event)
    {
      return delegate instanceof ICompletionProposalExtension2 && ((ICompletionProposalExtension2)delegate).validate(delegateDocument, jetToJava(offset), event);
    }

    class CompletionTransaction extends JavaDocumentTransaction
    {
      public CompletionTransaction(JETEditor jetEditor)
      {
        super(jetEditor, Collections.singletonList(jetEditor.getJETPosition()), true, false);
      }

      @Override
      protected void postCommit(List<TrackedPosition> jetPositions)
      {
        Point finalJavaSelectionRange = delegate.getSelection(delegateDocument);
        if (finalJavaSelectionRange != null)
        {
          int offset = finalJavaSelectionRange.x - javaPosition.getOffset();
          if (offset > 0)
          {
            jetEditor.getSourceViewer().setSelectedRange(jetPosition.getOffset() + offset, finalJavaSelectionRange.y);
          }
        }

        // Ensure that pop-up in Java view, if any, is dismissed.
        Event event = new Event();
        event.character = SWT.ESC;
        event.keyCode = SWT.ESC;
        jetEditor.getJavaSourceViewer().getTextWidget().notifyListeners(SWT.KeyDown, event);
      }
    }
  }

  static class JavaDocumentTransaction implements IDocumentListener
  {
    private static final Pattern IMPORT_PATTERN = Pattern.compile("import ([^;]+);");

    protected final JETEditor jetEditor;

    protected final List<TrackedPosition> jetPositions;

    private final boolean transformBraces;

    private final boolean ignoreOutOfScopeChanges;

    public JavaDocumentTransaction(JETEditor jetEditor, List<TrackedPosition> jetPositions, boolean transformBraces, boolean ignoreOutOfScopeChanges)
    {
      this.jetEditor = jetEditor;
      this.jetPositions = jetPositions;
      this.transformBraces = transformBraces;
      this.ignoreOutOfScopeChanges = ignoreOutOfScopeChanges;
    }

    public void modify(IDocument document, Runnable javaModifier)
    {
      start();
      jetEditor.getDocumentManager().setEnableJavaSynchronization(false);
      document.addDocumentListener(this);
      try
      {
        javaModifier.run();
        if (status == null)
        {
          commit(document);
        }
      }
      catch (Exception exception)
      {
        status = CodeGenUIPlugin.toStatus(IStatus.ERROR, exception);
      }
      finally
      {
        document.removeDocumentListener(this);
        jetEditor.getDocumentManager().setEnableJavaSynchronization(true);
        stop();
      }
    }

    protected void startDocumentRewriteSession(ISourceViewer sourceViewer, DocumentRewriteSessionType type, boolean rememberSelection)
    {
      if (rememberSelection)
      {
        try
        {
          Method rememberSelectionMethod = SourceViewer.class.getDeclaredMethod("rememberSelection");
          rememberSelectionMethod.setAccessible(true);
          rememberSelectionMethod.invoke(sourceViewer);
        }
        catch (Exception exception)
        {
          throw new RuntimeException(exception);
        }
      }

      ((IDocumentExtension4)sourceViewer.getDocument()).startRewriteSession(type);
    }

    protected void stopDocumentRewriteSession(ISourceViewer sourceViewer, boolean restoreSelection)
    {
      IDocumentExtension4 extension = (IDocumentExtension4)sourceViewer.getDocument();
      extension.stopRewriteSession(extension.getActiveRewriteSession());

      if (restoreSelection)
      {
        try
        {
          Method rememberSelectionMethod = SourceViewer.class.getDeclaredMethod("restoreSelection");
          rememberSelectionMethod.setAccessible(true);
          rememberSelectionMethod.invoke(sourceViewer);
        }
        catch (Exception exception)
        {
          throw new RuntimeException(exception);
        }
      }
    }

    protected void start()
    {
    }

    protected void stop()
    {
    }

    private List<String> imports = new ArrayList<String>();

    private IStatus status;

    public IStatus getStatus()
    {
      return status == null ? Status.OK_STATUS : status;
    }

    public void documentAboutToBeChanged(DocumentEvent event)
    {
    }

    public void documentChanged(DocumentEvent event)
    {
      if (status == null)
      {
        for (TrackedPosition jetPosition : jetPositions)
        {
          TrackedPosition javaPosition = jetPosition.getOpposite();
          if (javaPosition.overlapsWith(event.getOffset(), event.getLength()))
          {
            return;
          }
        }

        String replacement = event.getText();
        Matcher matcher = IMPORT_PATTERN.matcher(replacement);
        if (matcher.matches())
        {
          String newImport = matcher.group(1);
          imports.add(newImport);
        }
        else if (!ignoreOutOfScopeChanges && replacement.trim().length() != 0)
        {
          status = new Status(IStatus.ERROR, CodeGenUIPlugin.getPlugin().getBundle().getSymbolicName(), "Changes outside the scope of the current document occurred.");
        }
      }
    }

    protected void commit(IDocument delegateDocument) throws Exception
    {
      SourceViewer jetSourceViewer = jetEditor.getJETSourceViewer();
      IUndoManager undoManager = jetSourceViewer.getUndoManager();
      undoManager.beginCompoundChange();
      try
      {
        MultiTextEdit textEdit = new MultiTextEdit();
        for (TrackedPosition jetPosition : jetPositions)
        {
          TrackedPosition javaPosition = jetPosition.getOpposite();
          if (!javaPosition.isDeleted())
          {
            String finalJavaText = javaPosition.getText();

            String originalTemplateJavaText = jetPosition.getText();

            if (!originalTemplateJavaText.equals(finalJavaText))
            {
              int orginalTemplateJavaTextLength = jetPosition.getLength();
              int finalJavaTextLength = javaPosition.getLength();
              int start = 0;
              while (start < finalJavaTextLength && start < orginalTemplateJavaTextLength && finalJavaText.charAt(start) == originalTemplateJavaText.charAt(start))
              {
                ++start;
              }

              if (start != orginalTemplateJavaTextLength - 1 || orginalTemplateJavaTextLength != finalJavaTextLength)
              {
                int end = 0;
                while (finalJavaTextLength - end > 0 && orginalTemplateJavaTextLength - end > 0
                    && finalJavaText.charAt(finalJavaTextLength - end - 1) == originalTemplateJavaText.charAt(orginalTemplateJavaTextLength - end - 1))
                {
                  ++end;
                }

                int replacementOffset = jetPosition.getOffset() + start;
                int replacementLength = orginalTemplateJavaTextLength - end - start;
                while (replacementLength < 0)
                {
                  // The replacement length could be negative because the tail end of the actual Java replacement text could exactly match the text in the original string.
                  // And that part will have been trimmed from the replacement text we've computed for application to the template.
                  ++replacementLength;
                  --end;
                }

                int finalJavaTextEnd = finalJavaTextLength - end;
                String replacementText = finalJavaTextEnd < start ? "" : handleReplacement(finalJavaText.substring(start, finalJavaTextEnd));
                ReplaceEdit replaceEdit = new ReplaceEdit(replacementOffset, replacementLength, replacementText);
                textEdit.addChild(replaceEdit);
              }
            }
          }
        }

        int jetDirectiveFileID = -1;
        int importsOffset = -1;
        boolean needsImportsAttribute = false;
        StringBuilder newImports = new StringBuilder();
        if (!imports.isEmpty())
        {
          JETDirectiveItem jetJETDirectiveItem = jetEditor.getCompilationUnit().getJETJETDirectiveItem();
          jetDirectiveFileID = jetJETDirectiveItem.getFileID();
          JETAttributeItem imports = jetJETDirectiveItem.getAttribute("imports");
          for (String newImport : this.imports)
          {
            if (imports == null)
            {
              importsOffset = jetJETDirectiveItem.getAttributes().getStopOffset();
              needsImportsAttribute = true;
              if (newImports.length() != 0)
              {
                newImports.append(' ');
              }
            }
            else
            {
              JETTokenItem importValue = imports.getValueToken();
              if (importsOffset == -1)
              {
                JETValueItem valueItem = importValue.getValueItem();
                importsOffset = valueItem.getStopOffset();
                if (!valueItem.getElements().isEmpty())
                {
                  newImports.append(' ');
                }
              }
              else
              {
                newImports.append(' ');
              }
            }

            newImports.append(newImport);
          }
        }

        if (importsOffset != -1)
        {
          String insertion = needsImportsAttribute ? " imports=\"" + newImports + "\"" : newImports.toString();
          ReplaceEdit insertImportsEdit = new ReplaceEdit(importsOffset, 0, insertion);
          if (jetDirectiveFileID != jetEditor.getFileID())
          {
            IDocument jetDirectiveDocument = jetEditor.getDocumentManager().getDocument(jetDirectiveFileID);
            if (jetDirectiveDocument != null)
            {
              try
              {
                insertImportsEdit.apply(jetDirectiveDocument);
              }
              catch (Exception exception)
              {
                CodeGenUIPlugin.getPlugin().log(exception);
              }
            }
          }
          else
          {
            textEdit.addChild(insertImportsEdit);
          }
        }

        try
        {
          TextEdit[] children = textEdit.getChildren();
          if (children.length > 0)
          {
            startDocumentRewriteSession(jetSourceViewer, children.length > 50 ? DocumentRewriteSessionType.UNRESTRICTED : DocumentRewriteSessionType.UNRESTRICTED_SMALL, false);
            IDocument document = jetSourceViewer.getDocument();
            textEdit.apply(document);
          }

          postCommit(jetPositions);
        }
        finally
        {
          stopDocumentRewriteSession(jetSourceViewer, false);
        }
      }
      finally
      {
        undoManager.endCompoundChange();
      }
    }

    private static Pattern BRACE_COLLAPSE_PATTERN = Pattern.compile("\\s\\s+\\{");

    private static Pattern TAB_REPLACEMENT_PATTERN = Pattern.compile("\t");

    private static Pattern INDENT_FIX_PATTERN_ = Pattern.compile("(\r?\n)  ");

    protected String handleReplacement(String replacement)
    {
      if (transformBraces)
      {
        String result = BRACE_COLLAPSE_PATTERN.matcher(replacement).replaceAll(" {");
        result = TAB_REPLACEMENT_PATTERN.matcher(result).replaceAll("  ");
        result = INDENT_FIX_PATTERN_.matcher(result).replaceAll("$1");
        return result;
      }

      return replacement;
    }

    protected void postCommit(List<TrackedPosition> jetPositions)
    {
    }
  }

  static class DelegatingContentAssistProcessor implements IContentAssistProcessor
  {
    private static final Pattern IGNORED_PROPOSAL_PATTERN = Pattern.compile("^(((TEXT)?_([0-9]+))|nl|(NL(_[0-9]+)?)) : String");

    private final JETEditor jetEditor;

    private final JETContentAssistProcessor jetContentAssistProcessor;

    private IContentAssistProcessor javaContentAssistProcessor;

    private IContentAssistProcessor delegate;

    public DelegatingContentAssistProcessor(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
      jetContentAssistProcessor = new JETContentAssistProcessor(jetEditor);
    }

    protected IContentAssistProcessor getJavaAssistProcessor()
    {
      if (javaContentAssistProcessor == null)
      {
        IContentAssistant contentAssist = jetEditor.getJavaEditor().getContentAssist();
        javaContentAssistProcessor = contentAssist.getContentAssistProcessor(IDocument.DEFAULT_CONTENT_TYPE);
      }
      return javaContentAssistProcessor;
    }

    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset)
    {
      final JETToken token = jetEditor.getTokenAt(offset);
      if (token == JETContentRule.TOKEN || token == JETTrailingWhitespaceContentRule.TOKEN || token == JETDirectiveRule.TOKEN || token == null)
      {
        delegate = jetContentAssistProcessor;
        return jetContentAssistProcessor.computeCompletionProposals(viewer, offset);
      }
      else if (token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN)
      {
        delegate = getJavaAssistProcessor();

        final ISourceViewer javaSourceViewer = jetEditor.getJavaEditor().getJavaSourceViewer();
        final Point javaSelectionRange = javaSourceViewer.getSelectedRange();
        final int javaCaretOffset = javaSelectionRange.x + javaSelectionRange.y;

        ICompletionProposal[] proposals = delegate.computeCompletionProposals(javaSourceViewer, javaCaretOffset);
        List<ICompletionProposal> filteredProposals = new ArrayList<ICompletionProposal>();
        Set<String> duplicates = new HashSet<String>();

        for (final ICompletionProposal completionProposal : proposals)
        {
          String displayString = completionProposal.getDisplayString();
          if (duplicates.add(displayString) && !IGNORED_PROPOSAL_PATTERN.matcher(displayString).find())
          {
            filteredProposals.add(new CompletionProposalDelegate(completionProposal, jetEditor));
          }
        }

        return filteredProposals.toArray(new ICompletionProposal [filteredProposals.size()]);
      }
      else
      {
        return null;
      }
    }

    public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset)
    {
      return null;
    }

    public char[] getCompletionProposalAutoActivationCharacters()
    {
      JETToken token = jetEditor.getTokenAtSelection(0);
      return token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN ? getJavaAssistProcessor().getCompletionProposalAutoActivationCharacters() : null;
    }

    public char[] getContextInformationAutoActivationCharacters()
    {
      JETToken token = jetEditor.getTokenAtSelection(0);
      return token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN ? getJavaAssistProcessor().getContextInformationAutoActivationCharacters() : null;
    }

    public String getErrorMessage()
    {
      return delegate != null ? delegate.getErrorMessage() : null;
    }

    public IContextInformationValidator getContextInformationValidator()
    {
      return null;
    }
  }

  static class DelegatingQuickAssistProcessor implements IQuickAssistProcessor
  {
    private JETEditor jetEditor;

    public DelegatingQuickAssistProcessor(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    @SuppressWarnings("restriction")
    protected IQuickAssistProcessor getJavaAssistProcessor(IQuickAssistInvocationContext invocationContext)
    {
      JavaEditor javaEditor = jetEditor.getJavaEditor();
      IQuickAssistAssistant quickAssistAssistant = javaEditor.getQuickAssistAssistant();
      if (invocationContext != null)
      {
        try
        {
          ArrayList<Annotation> resultingAnnotations = new ArrayList<Annotation>();
          org.eclipse.jdt.internal.ui.text.correction.JavaCorrectionAssistant.collectQuickFixableAnnotations(
            javaEditor,
            invocationContext.getOffset(),
            invocationContext.getLength() != 0,
            resultingAnnotations);
          Field fCurrentAnnotationsField = quickAssistAssistant.getClass().getDeclaredField("fCurrentAnnotations");
          fCurrentAnnotationsField.setAccessible(true);
          fCurrentAnnotationsField.set(quickAssistAssistant, resultingAnnotations.toArray(new Annotation [resultingAnnotations.size()]));
        }
        catch (Exception exception)
        {
        }
      }

      return quickAssistAssistant.getQuickAssistProcessor();
    }

    protected IQuickAssistInvocationContext getJavaInvocationContext(IQuickAssistInvocationContext invocationContext)
    {
      final JETToken token = jetEditor.getTokenAt(invocationContext.getOffset());
      if (token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN)
      {
        final ISourceViewer javaSourceViewer = jetEditor.getJavaEditor().getJavaSourceViewer();
        final Point javaSelectionRange = javaSourceViewer.getSelectedRange();
        return new TextInvocationContext(javaSourceViewer, javaSelectionRange.x, javaSelectionRange.y);
      }
      else
      {
        return null;
      }
    }

    public boolean canAssist(IQuickAssistInvocationContext invocationContext)
    {
      IQuickAssistInvocationContext javaInvocationContext = getJavaInvocationContext(invocationContext);
      return javaInvocationContext != null && getJavaAssistProcessor(javaInvocationContext).canAssist(javaInvocationContext);
    }

    public ICompletionProposal[] computeQuickAssistProposals(IQuickAssistInvocationContext invocationContext)
    {
      IQuickAssistInvocationContext javaInvocationContext = getJavaInvocationContext(invocationContext);
      if (javaInvocationContext != null)
      {
        ICompletionProposal[] quickAssistProposals = getJavaAssistProcessor(javaInvocationContext).computeQuickAssistProposals(javaInvocationContext);
        if (quickAssistProposals != null)
        {
          List<ICompletionProposal> delegatingProposals = new ArrayList<ICompletionProposal>(quickAssistProposals.length);
          for (ICompletionProposal completionProposal : quickAssistProposals)
          {
            delegatingProposals.add(new CompletionProposalDelegate(completionProposal, jetEditor));
          }
          return delegatingProposals.toArray(new ICompletionProposal [delegatingProposals.size()]);
        }
      }
      return null;
    }

    public String getErrorMessage()
    {
      return getJavaAssistProcessor(null).getErrorMessage();
    }

    public boolean canFix(Annotation annotation)
    {
      return getJavaAssistProcessor(null).canFix(annotation);
    }
  }

  static class JETContentAssistProcessor extends TemplateCompletionProcessor
  {
    private static final Map<String, JETTemplateContextType> JET_CONTEXT_TYPES = new HashMap<String, JETTemplateContextType>();

    private static final Map<JETToken, JETTemplateContextType> JET_TOKEN_CONTEXT_TYPES = new HashMap<JETToken, JETTemplateContextType>();

    private static Image JET_IMAGE = CodeGenUIPlugin.getPlugin().getActualImage("full/obj16/JET");

    private final JETEditor jetEditor;

    static
    {
      new JETContentContextType();
      new JETDirectiveContextType();
    }

    public JETContentAssistProcessor(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    @Override
    protected Template[] getTemplates(String contextTypeId)
    {
      JETTemplateContextType jetTemplateContextType = JET_CONTEXT_TYPES.get(contextTypeId);
      return jetTemplateContextType == null ? null : jetTemplateContextType.getTemplates(jetEditor.getEditorInput());
    }

    @Override
    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset)
    {
      try
      {
        return super.computeCompletionProposals(viewer, offset);
      }
      finally
      {
        for (JETTemplateContextType jetTemplateContextType : JET_CONTEXT_TYPES.values())
        {
          jetTemplateContextType.resetContext();
        }
      }
    }

    @Override
    protected String extractPrefix(ITextViewer viewer, int offset)
    {
      return "";
    }

    @Override
    protected ICompletionProposal createProposal(Template template, TemplateContext context, IRegion region, int relevance)
    {
      return new JETTemplateProposal(template, context, region, getImage(template), relevance);
    }

    @Override
    protected TemplateContextType getContextType(ITextViewer viewer, IRegion region)
    {
      JETTokenRegion tokenRegion = jetEditor.getTokenRegionAt(region.getOffset());

      // If we are right at the start, even in an empty file, treat it like we are in content.
      JETToken token = tokenRegion == null || tokenRegion.getOffset() == region.getOffset() ? JETContentRule.TOKEN : tokenRegion.getToken();
      JETTemplateContextType jetTemplateContextType = JET_TOKEN_CONTEXT_TYPES.get(token.getBaseToken());
      if (jetTemplateContextType != null)
      {
        jetTemplateContextType.setContext(jetEditor, region);
      }
      return jetTemplateContextType;
    }

    @Override
    protected Image getImage(Template template)
    {
      return JET_IMAGE;
    }

    private static class JETTemplateProposal extends TemplateProposal implements ICompletionProposalExtension6
    {
      private StyledString displayString;

      public JETTemplateProposal(Template template, TemplateContext context, IRegion region, Image image, int relevance)
      {
        super(template, context, region, image, relevance);
      }

      @Override
      public String getDisplayString()
      {
        return getStyledDisplayString().toString();
      }

      public StyledString getStyledDisplayString()
      {
        if (displayString == null)
        {
          String name = getTemplate().getName();
          String description = getTemplate().getDescription();
          displayString = new StyledString(name, StyledString.COUNTER_STYLER);
          displayString.append(" - ");
          displayString.append(description, StyledString.QUALIFIER_STYLER);
        }
        return displayString;
      }
    }

    static class JETTemplateContextType extends TemplateContextType
    {
      private JETEditor jetEditor;

      private IRegion region;

      public JETTemplateContextType(String id, JETToken token)
      {
        super(id);
        JET_CONTEXT_TYPES.put(id, this);
        JET_TOKEN_CONTEXT_TYPES.put(token, this);
      }

      public JETEditor getEditor()
      {
        return jetEditor;
      }

      public IRegion getRegion()
      {
        return region;
      }

      public void setContext(JETEditor jetEditor, IRegion region)
      {
        this.jetEditor = jetEditor;
        this.region = region;
      }

      public void resetContext()
      {
        jetEditor = null;
        region = null;
      }

      public Template[] getTemplates(IEditorInput input)
      {
        return null;
      }
    }

    static class JETContentContextType extends JETTemplateContextType
    {
      private static String ID = "org.eclipse.code.ui.jet.content";

      private static Pattern JET_DIRECTIVE_PATTERN = Pattern.compile("\\s*<%@\\s*jet\\s+.*%>", Pattern.DOTALL);

      private static final Template JET_DIRECTIVE_TEMPLATE = new Template(
        "<%@jet%>",
        "@jet directive to minimally specify the Java class name",
        ID,
        "<%@jet package=\"${java_package_name}\" class=\"${java_class_name}\" imports=\"${java_imports}\"%>\n",
        true);

      private static final Template JET_SCRIPTLET_TEMPLATE = new Template("<%%>", "scriptlet for specifying Java statement logic", JETContentContextType.ID, "<%${}%>", true);

      private static final Template JET_EXPRESSION_TEMPLATE = new Template("<%=%>", "expression for specifying Java expression logic", JETContentContextType.ID, "<%=${}%>", true);

      private static final Template JET_SIMPLE_INCLUDE_TEMPLATE = new Template(
        "<%@include%>",
        "@include directive for including a 'jetinc' file",
        ID,
        "<%@include file=\"${file}\"%>",
        true);

      private static final Template JET_OPTIONAL_INCLUDE_TEMPLATE = new Template(
        "<%@include fail=\"silent\"%>",
        "@include directive for including a 'jetinc' file, ignoring when it doesn't exist",
        ID,
        "<%@include file=\"${file}\" fail=\"silent\"%>",
        true);

      private static final Template JET_ALTERNATIVE_INCLUDE_TEMPLATE = new Template(
        "<%@include fail=\"alternative\"%>",
        "@include directive for including a 'jetinc' file, using the @start/@end block when it doesn't exist",
        ID,
        "<%@include file=\"${file}\" fail=\"alternative\"%>\n<%@start%>\n${}<%@end%>\n",
        true);

      private static final Template JET_COPYRIGHT_COMMENT_TEMPLATE = new Template(
        "<%--copyright--%>",
        "a comment at the start of the file for specifying the copyright",
        ID,
        "<%--\nCopyright " + System.getProperty("user.name") + " " + Calendar.getInstance().get(Calendar.YEAR) + "\n--%>\n",
        true);

      private static final Template JET_COMMENT_TEMPLATE = new Template("<%--%>", "comment for specifying excluded content", JETContentContextType.ID, "<%-${}-%>", true);

      private static final Template JET_COMMENT_TEMPLATE_WITH_TAG = new Template(
        "<%-[]-%>",
        "comment for specifying a tag in the content outline",
        JETContentContextType.ID,
        "<%-[${Tag}]-%>",
        true);

      public JETContentContextType()
      {
        super(ID, JETContentRule.TOKEN);
      }

      private Template convert(Template template, String lineDelimeter)
      {
        return new Template(
          template.getName(),
          template.getDescription(),
          template.getContextTypeId(),
          template.getPattern().replace("\n", lineDelimeter),
          template.isAutoInsertable());
      }

      @Override
      public Template[] getTemplates(IEditorInput input)
      {
        ITextViewer viewer = getEditor().getSourceViewer();
        IDocument document = viewer.getDocument();
        String lineDelimiter = TextUtilities.getDefaultLineDelimiter(document);

        List<Template> result = new ArrayList<Template>();
        if (viewer.getSelectedRange().x == 0)
        {
          result.add(convert(JET_COPYRIGHT_COMMENT_TEMPLATE, lineDelimiter));
        }

        boolean isJET = input == null || input.getName() == null || input.getName().endsWith("jet");
        if (isJET)
        {
          try
          {
            IRegion lineInformation = document.getLineInformation(0);
            String firstLine = document.get(lineInformation.getOffset(), lineInformation.getLength());
            if (!JET_DIRECTIVE_PATTERN.matcher(firstLine).matches())
            {
              JETCompilationUnit compilationUnit = getEditor().getCompilationUnit();
              if (compilationUnit == null || compilationUnit.getJETJETDirectiveItem() == null || compilationUnit.getJETJETDirectiveItem().getLength() == 0)
              {
                result.add(convert(JET_DIRECTIVE_TEMPLATE, lineDelimiter));
              }
            }
          }
          catch (BadLocationException exception)
          {
          }
        }

        result.add(convert(JET_SCRIPTLET_TEMPLATE, lineDelimiter));
        result.add(convert(JET_EXPRESSION_TEMPLATE, lineDelimiter));
        result.add(convert(JET_SIMPLE_INCLUDE_TEMPLATE, lineDelimiter));
        result.add(convert(JET_OPTIONAL_INCLUDE_TEMPLATE, lineDelimiter));
        result.add(convert(JET_ALTERNATIVE_INCLUDE_TEMPLATE, lineDelimiter));
        result.add(convert(JET_COMMENT_TEMPLATE, lineDelimiter));
        result.add(convert(JET_COMMENT_TEMPLATE_WITH_TAG, lineDelimiter));

        return result.toArray(new Template [result.size()]);
      }
    }

    private static class JETDirectiveContextType extends JETTemplateContextType
    {
      private static String ID = "org.eclipse.code.ui.jet.directive";

      private static final Map<String, List<Template>> ATTRIBUTE_TEMPLATES = new HashMap<String, List<Template>>();

      static
      {
        List<Template> jetTemplates = new ArrayList<Template>();
        jetTemplates.add(new Template("class", "specify the Java class name of the class", ID, "class=\"${java_class_name}\"", false));
        jetTemplates.add(new Template("package", "specify the Java package name of the class", ID, "package=\"${java_package_name}\"", false));
        jetTemplates.add(new Template("imports", "specify the Java imports for the class", ID, "imports=\"${java_imports}\"", false));
        jetTemplates.add(
          new Template("builder", "specify the builder to be used in the generate method of the class", ID, "builder=\"StringBuilder ${builder} = new StringBuilder()\"", false));
        jetTemplates.add(new Template("minimize", "whether to mimize the footprint of the literal constants of the class", ID, "minimize=\"${true}\"", false));
        jetTemplates.add(
          new Template("nlString", "specify the Java expression used to extract the default line delimiter of the class", ID, "nlString=\"${global_expression}\"", false));
        jetTemplates.add(new Template("skeleton", "specify a Java class to be used as the skeleton of the class", ID, "skeleton=\"${skeleton_java_file}\"", false));
        jetTemplates.add(new Template("version", "specify and arbtirary used version for the templates", ID, "version=\"${version}\"", false));
        ATTRIBUTE_TEMPLATES.put("jet", jetTemplates);

        List<Template> includeTemplates = new ArrayList<Template>();
        includeTemplates.add(new Template("file", "specify file to include in the template", ID, "file=\"${file}\"", false));
        includeTemplates.add(new Template("fail", "specify to ignore a missing file", ID, "fail=\"${silent}\"", false));
        ATTRIBUTE_TEMPLATES.put("include", includeTemplates);
      }

      public JETDirectiveContextType()
      {
        super(ID, JETDirectiveRule.TOKEN);
      }

      private Template convert(Template template, String prefix, String suffix)
      {
        return new Template(template.getName(), template.getDescription(), template.getContextTypeId(), prefix + template.getPattern() + suffix, template.isAutoInsertable());
      }

      @Override
      public Template[] getTemplates(IEditorInput input)
      {
        JETEditor jetEditor = getEditor();

        // Ignore the prefix.
        IRegion region = getRegion();
        int offset = region.getOffset() + region.getLength();
        JETTokenRegion tokenRegion = jetEditor.getTokenRegionAt(offset);
        try
        {
          List<Template> result = new ArrayList<Template>();
          int tokenRegionOffset = tokenRegion.getOffset();
          int tokenRegionLength = tokenRegion.getLength();
          String directive = jetEditor.getSourceViewer().getDocument().get(tokenRegionOffset, tokenRegionLength);
          JETDirectiveItem jetDirectiveItem = JETParser.parseDirective(directive);
          JETAttributeListItem attributes = jetDirectiveItem.getAttributes();
          int relativeOffset = offset - tokenRegionOffset;
          JETItem nameItem = jetDirectiveItem.getNameItem();
          String directiveName = nameItem.getText();
          List<Template> templates = ATTRIBUTE_TEMPLATES.get(directiveName);
          if (templates != null)
          {
            boolean valid = false;
            JETItem previousItem = nameItem;
            for (JETAttributeItem jetAttributeItem : attributes.getAttributes())
            {
              int previousStopOffset = previousItem.getStopOffset();
              int nextStartOffset = jetAttributeItem.getStartOffset();
              if (relativeOffset >= previousStopOffset && relativeOffset <= nextStartOffset)
              {
                valid = true;
                break;
              }
              else
              {
                previousItem = jetAttributeItem;
              }
            }

            if (!valid && relativeOffset >= attributes.getStopOffset() && relativeOffset <= tokenRegionLength - 2)
            {
              valid = true;
            }

            if (valid)
            {
              char characterBeforeInsertion = directive.charAt(relativeOffset - 1);
              char characterAfterInsertion = directive.charAt(relativeOffset);
              String prefix = Character.isWhitespace(characterBeforeInsertion) ? "" : " ";
              String suffix = Character.isWhitespace(characterAfterInsertion) || characterAfterInsertion == '%' ? "" : " ";
              for (Template template : templates)
              {
                if (jetDirectiveItem.getAttribute(template.getName()) == null)
                {
                  result.add(convert(template, prefix, suffix));
                }
              }
            }
          }

          return result.toArray(new Template [result.size()]);
        }
        catch (Exception exception)
        {
          return null;
        }
      }
    }
  }

  static class JETProblemAnnotation extends Annotation implements IAnnotationPresentation
  {
    private static final Image[] SEVERITY_IMAGES;

    private static final Image[] DISABLED_SEVERITY_IMAGES;

    static
    {
      ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
      SEVERITY_IMAGES = new Image []{
        sharedImages.getImage(ISharedImages.IMG_OBJS_INFO_TSK),
        sharedImages.getImage(ISharedImages.IMG_OBJS_WARN_TSK),
        sharedImages.getImage(ISharedImages.IMG_OBJS_ERROR_TSK) };
      DISABLED_SEVERITY_IMAGES = new Image []{
        new Image(SEVERITY_IMAGES[0].getDevice(), SEVERITY_IMAGES[0], SWT.IMAGE_GRAY),
        new Image(SEVERITY_IMAGES[1].getDevice(), SEVERITY_IMAGES[1], SWT.IMAGE_GRAY),
        new Image(SEVERITY_IMAGES[2].getDevice(), SEVERITY_IMAGES[2], SWT.IMAGE_GRAY) };
    }

    private static final String[] SEVERITY_TYPES = new String []{
      "org.eclipse.ui.workbench.texteditor.info",
      "org.eclipse.ui.workbench.texteditor.warning",
      "org.eclipse.ui.workbench.texteditor.error" };

    private final boolean disabled;

    private final int severity;

    private final Position position;

    public JETProblemAnnotation(int severity, String message, Position position)
    {
      super(SEVERITY_TYPES[severity], false, message);
      this.severity = severity;
      this.position = position;
      this.disabled = false;
    }

    public JETProblemAnnotation(MarkerAnnotation annotation, Position position)
    {
      super(SEVERITY_TYPES[getSeverity(annotation)], false, annotation.getText());
      severity = getSeverity(annotation);
      this.position = position;
      this.disabled = true;
    }

    public Position getPosition()
    {
      return position;
    }

    public int getSeverity()
    {
      return severity;
    }

    public int getLayer()
    {
      return 6 + severity + (disabled ? 1 : 0);
    }

    private Image getImage()
    {
      return (disabled ? DISABLED_SEVERITY_IMAGES : SEVERITY_IMAGES)[severity];
    }

    public void paint(GC gc, Canvas canvas, Rectangle bounds)
    {
      ImageUtilities.drawImage(getImage(), gc, canvas, bounds, SWT.CENTER, SWT.TOP);
    }

    private static int getSeverity(MarkerAnnotation markerAnnotation)
    {
      try
      {
        IMarker marker = markerAnnotation.getMarker();
        if (marker != null)
        {
          Object severity = marker.getAttribute(IMarker.SEVERITY);
          return severity instanceof Integer ? (Integer)severity : IMarker.SEVERITY_INFO;
        }
      }
      catch (CoreException exception)
      {
      }
      return IMarker.SEVERITY_ERROR;
    }
  }

  static class ColorManager implements IPropertyChangeListener
  {
    private static ColorManager INSTANCE = new ColorManager();

    private static final String PROPERTY_PREFIX = "org.eclipse.emf.codegen.ui.jet.";

    private final Set<JETToken> tokens = new LinkedHashSet<JETEditor.JETToken>();

    private final Map<Control, ISourceViewer> sourceViewers = new HashMap<Control, ISourceViewer>();

    private final Map<Color, Map<Color, Color>> blendedColors = new HashMap<Color, Map<Color, Color>>();

    private final Map<RGB, Color> colors = new HashMap<RGB, Color>();

    private final DisposeListener disposeListener = new DisposeListener()
      {
        public void widgetDisposed(DisposeEvent event)
        {
          sourceViewers.remove(event.widget);
          if (sourceViewers.isEmpty())
          {
            if (trace)
            {
              System.out.println("unhook color");
            }
            JFaceResources.getColorRegistry().removeListener(ColorManager.this);
          }
        }
      };

    private ColorManager()
    {
    }

    public Color getColor(int red, int green, int blue)
    {
      RGB rgb = new RGB(red, green, blue);
      Color color = colors.get(rgb);
      if (color == null)
      {
        color = new Color(Display.getDefault(), rgb);
        colors.put(rgb, color);
      }
      return color;
    }

    public Color getBlendedColor(Color foreground, Color background)
    {
      Map<Color, Color> blendedBackgroundColors = blendedColors.get(foreground);
      if (blendedBackgroundColors == null)
      {
        blendedBackgroundColors = new HashMap<Color, Color>();
        blendedColors.put(foreground, blendedBackgroundColors);
      }
      Color blendedColor = blendedBackgroundColors.get(background);
      if (blendedColor == null)
      {
        blendedColor = new Color(foreground.getDevice(), ColorUtil.blend(foreground.getRGB(), background.getRGB(), 50));
        blendedBackgroundColors.put(background, blendedColor);
      }
      return blendedColor;
    }

    public String getProperty(JETToken token)
    {
      return "org.eclipse.emf.codegen.ui.jet." + (token == null ? JETContentRule.TOKEN : token.getBaseToken()).getType() + "Background";
    }

    public void register(ISourceViewer sourceViewer)
    {
      if (sourceViewers.isEmpty())
      {
        JFaceResources.getColorRegistry().addListener(this);
      }

      StyledText control = sourceViewer.getTextWidget();
      sourceViewers.put(control, sourceViewer);
      control.addDisposeListener(disposeListener);
    }

    public void register(JETToken token)
    {
      tokens.add(token);
      update(token);
    }

    private void update(JETToken token)
    {
      String type = token.getBaseToken().getType();
      token.setData(new JETTextAttribute(getForeground(type), getBackground(type), token.getTextStyle(), token.getBorderStyle(), null, token));
    }

    private Color getForeground(String type)
    {
      return JFaceResources.getColorRegistry().get("org.eclipse.emf.codegen.ui.jet." + type + "Foreground");
    }

    private Color getBackground(String type)
    {
      return JFaceResources.getColorRegistry().get("org.eclipse.emf.codegen.ui.jet." + type + "Background");
    }

    public void propertyChange(PropertyChangeEvent event)
    {
      if (event.getProperty().startsWith(PROPERTY_PREFIX))
      {
        Display.getDefault().asyncExec(new Runnable()
          {
            public void run()
            {
              for (JETToken token : tokens)
              {
                update(token);
              }

              for (ISourceViewer sourceViewer : sourceViewers.values())
              {
                sourceViewer.invalidateTextPresentation();
              }
            }
          });
      }
    }

    private static class JETTextAttribute extends TextAttribute
    {
      private final JETToken token;

      private final int borderStyle;

      public JETTextAttribute(Color foreground, Color background, int textStyle, int borderStyle, Font font, JETToken token)
      {
        super(foreground, background, textStyle, font);
        this.token = token;
        this.borderStyle = borderStyle;
      }

      public JETToken getToken()
      {
        return token;
      }

      public int getBorderStyle()
      {
        return borderStyle;
      }

      @Override
      public boolean equals(Object object)
      {
        return object == this;
      }
    }
  }

  static class JETBracketMatcher extends DefaultCharacterPairMatcher
  {
    private final static char[] BRACKETS = { //
      '{',
      '}', //
      '(',
      ')', //
      '[',
      ']', //
      '<',
      '>', //
      '%',
      '%', //
      '=',
      '%', //
      '@',
      '%' //
    };

    private final JETEditor jetEditor;

    private int customAnchor;

    public JETBracketMatcher(JETEditor jetEditor)
    {
      super(BRACKETS);
      this.jetEditor = jetEditor;
    }

    private JETToken getToken(int offset)
    {
      return jetEditor.getTokenAt(offset);
    }

    private Point getTokenRange(int offset)
    {
      return jetEditor.getTokenRangeAt(offset);
    }

    @Override
    public IRegion match(IDocument document, int offset)
    {
      JETToken token = getToken(offset);
      if (token == null)
      {
        return null;
      }

      Point tokenRange;
      if (token.getBaseToken() == JETContentRule.TOKEN)
      {
        if (offset > 1)
        {
          token = getToken(offset - 1);
          if (token == null || token.getBaseToken() == JETContentRule.TOKEN)
          {
            return null;
          }

          tokenRange = getTokenRange(offset - 1);
        }
        else
        {
          return null;
        }
      }
      else
      {
        tokenRange = getTokenRange(offset);
      }

      for (;;)
      {
        try
        {
          // Trim of the preceding white space that's included in comments, scriptlets, and directives.
          if (document.getChar(tokenRange.x) == ' ')
          {
            ++tokenRange.x;
            --tokenRange.y;
          }
          else
          {
            break;
          }
        }
        catch (BadLocationException exception)
        {
          break;
        }
      }

      int effectiveOffset = offset;
      boolean isCloseBrace = false;
      if (token == JETScriptletRule.TOKEN && tokenRange.y == 5)
      {
        try
        {
          isCloseBrace = "<%}%>".equals(document.get(tokenRange.x, tokenRange.y));
          if (isCloseBrace)
          {
            effectiveOffset = tokenRange.x + 3;
          }
        }
        catch (BadLocationException exception)
        {
        }
      }

      if (!isCloseBrace)
      {
        IRegion jetMatch = token.match(tokenRange, offset);
        if (jetMatch != null)
        {
          customAnchor = offset > jetMatch.getOffset() + jetMatch.getLength() - 2 ? RIGHT : LEFT;
          return jetMatch;
        }
      }

      if (token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN)
      {
        JavaEditor javaEditor = jetEditor.getJavaEditor();
        if (javaEditor != null)
        {
          ISourceViewer javaSourceViewer = javaEditor.getJavaSourceViewer();
          IDocument javaDocument = javaSourceViewer.getDocument();
          DefaultCharacterPairMatcher javaBracketMatcher = javaEditor.getJavaBracketMatcher();
          if (javaBracketMatcher != null)
          {
            Position correspondingJavaPoint = jetEditor.getCorrespondingJavaPosition(effectiveOffset, 0);
            if (correspondingJavaPoint == null)
            {
              return null;
            }

            IRegion javaRegion = javaBracketMatcher.match(javaDocument, correspondingJavaPoint.offset);
            if (javaRegion == null)
            {
              return null;
            }

            Position correspondingTemplatePointStart = jetEditor.getCorrespondingTemplatePosition(javaRegion.getOffset(), 0);
            if (correspondingTemplatePointStart == null)
            {
              return null;
            }

            Position correspondingTemplatePositionEnd = jetEditor.getCorrespondingTemplatePosition(javaRegion.getOffset() + javaRegion.getLength() - 1, 0);
            if (correspondingTemplatePositionEnd == null)
            {
              return null;
            }

            customAnchor = javaBracketMatcher.getAnchor();
            if (customAnchor != -1)
            {
              return new Region(correspondingTemplatePointStart.offset, correspondingTemplatePositionEnd.offset - correspondingTemplatePointStart.offset + 1);
            }
          }
        }
      }

      customAnchor = -1;
      return null;
    }

    @Override
    public int getAnchor()
    {
      return customAnchor == -1 ? super.getAnchor() : customAnchor;
    }
  }

  static class JETSourceViewerConfiguration extends TextSourceViewerConfiguration
  {
    private final DelegatingContentAssistProcessor delegatingContentAssistProcessor;

    private final DelegatingQuickAssistProcessor delegatingQuickAssistProcessor;

    private final BufferedRuleBasedScanner scanner = new BufferedRuleBasedScanner(1000);

    private final CompletionListener completionListener;

    private final JETEditor jetEditor;

    public JETSourceViewerConfiguration(IPreferenceStore preferenceStore, JETEditor jetEditor)
    {
      super(preferenceStore);

      this.jetEditor = jetEditor;

      delegatingContentAssistProcessor = new DelegatingContentAssistProcessor(jetEditor);
      delegatingQuickAssistProcessor = new DelegatingQuickAssistProcessor(jetEditor);
      completionListener = new CompletionListener(jetEditor);

      scanner.setRules(
        new IRule []{
          new JETCommentRule(),
          new JETExpressionRule(),
          new JETDirectiveRule(),
          new JETScriptletRule(),
          new JETContentRule(),
          new JETTrailingWhitespaceContentRule(),
          new JETCommentErrorRule(),
          new JETExpressionErrorRule(),
          new JETDirectiveErrorRule(),
          new JETScriptletErrorRule() });
    }

    @Override
    public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer)
    {
      PresentationReconciler reconciler = createPresentationReconciler();
      reconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));

      DefaultDamagerRepairer damageRepairer = new JETDamageRepairer(jetEditor, scanner);
      reconciler.setDamager(damageRepairer, IDocument.DEFAULT_CONTENT_TYPE);
      reconciler.setRepairer(damageRepairer, IDocument.DEFAULT_CONTENT_TYPE);

      return reconciler;
    }

    protected PresentationReconciler createPresentationReconciler()
    {
      return new JETPresentationReconciler(jetEditor);
    }

    @Override
    @SuppressWarnings("restriction")
    public IAnnotationHover getAnnotationHover(ISourceViewer sourceViewer)
    {
      return new org.eclipse.jdt.internal.ui.text.HTMLAnnotationHover(false)
        {
          @Override
          protected boolean isIncluded(Annotation annotation)
          {
            return isShowInVerticalRuler(annotation);
          }
        };
    }

    @Override
    public IUndoManager getUndoManager(ISourceViewer sourceViewer)
    {
      int undoLevel = fPreferenceStore == null || !fPreferenceStore.contains(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_UNDO_HISTORY_SIZE)
        ? 25 : fPreferenceStore.getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_UNDO_HISTORY_SIZE);
      return new CompositeUndoManager(jetEditor, undoLevel);
    }

    @SuppressWarnings("restriction")
    @Override
    public IContentAssistant getContentAssistant(ISourceViewer sourceViewer)
    {
      ContentAssistant contentAssistant = new ContentAssistant();
      contentAssistant.setInformationControlCreator(getInformationControlCreator(sourceViewer));
      contentAssistant.setContentAssistProcessor(delegatingContentAssistProcessor, IDocument.DEFAULT_CONTENT_TYPE);
      contentAssistant.addCompletionListener(completionListener);

      org.eclipse.jdt.internal.ui.text.ContentAssistPreference.configure(contentAssistant, org.eclipse.jdt.internal.ui.JavaPlugin.getDefault().getPreferenceStore());

      contentAssistant.enableColoredLabels(true);
      return contentAssistant;
    }

    @SuppressWarnings("restriction")
    @Override
    public IQuickAssistAssistant getQuickAssistAssistant(ISourceViewer sourceViewer)
    {
      QuickAssistAssistant assistant = new QuickAssistAssistant();
      assistant.setQuickAssistProcessor(delegatingQuickAssistProcessor);

      try
      {
        // Not available until 3.7, i.e., Helios.
        assistant.getClass().getMethod("setRestoreCompletionProposalSize", IDialogSettings.class).invoke(
          assistant,
          CodeGenUIPlugin.getPlugin().getDialogSettingsSection("quick_assist_proposal_size"));
      }
      catch (Exception exception)
      {
        // Ignore.
      }

      assistant.setInformationControlCreator(new IInformationControlCreator()
        {
          public IInformationControl createInformationControl(Shell parent)
          {
            return new DefaultInformationControl(parent, org.eclipse.ui.internal.editors.text.EditorsPlugin.getAdditionalInfoAffordanceString());
          }
        });
      assistant.addCompletionListener(completionListener);
      return assistant;
    }

    @Override
    public IInformationControlCreator getInformationControlCreator(ISourceViewer sourceViewer)
    {
      return new IInformationControlCreator()
        {
          public IInformationControl createInformationControl(Shell parent)
          {
            return new DefaultInformationControl(parent, false);
          }
        };
    }

    @Override
    public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType)
    {
      return jetEditor.delegatingTextHover;
    }

    @Override
    protected Map<String, IAdaptable> getHyperlinkDetectorTargets(ISourceViewer sourceViewer)
    {
      Map<String, IAdaptable> targets = super.getHyperlinkDetectorTargets(sourceViewer);
      targets.put("org.eclipse.emf.codegen.ui.jetTemplate", jetEditor);
      return targets;
    }

    static class CompletionListener implements ICompletionListener
    {
      private final JETEditor jetEditor;

      public CompletionListener(JETEditor jetEditor)
      {
        this.jetEditor = jetEditor;
      }

      public void assistSessionStarted(ContentAssistEvent event)
      {
        jetEditor.setShowingContentAssist(true);
      }

      public void assistSessionEnded(ContentAssistEvent event)
      {
        jetEditor.setShowingContentAssist(false);
      }

      public void selectionChanged(ICompletionProposal proposal, boolean smartToggle)
      {
      }
    }
  }

  static final class CompositeUndoManager implements IUndoManager, IUndoManagerExtension, ITextInputListener
  {
    private final JETEditor jetEditor;

    private final int undoLevel;

    private int compoundChange;

    private final Map<IDocument, SharedTextViewerUndoManager> managers = new HashMap<IDocument, SharedTextViewerUndoManager>();

    private final IUndoContext undoContext = new IUndoContext()
      {
        public boolean matches(IUndoContext context)
        {
          for (SharedTextViewerUndoManager undoManager : managers.values())
          {
            IUndoContext undoContext = undoManager.getUndoContext();
            if (undoContext.matches(context))
            {
              return true;
            }
          }
          return false;
        }

        public String getLabel()
        {
          return "Shared Undo Context";
        }
      };

    private ITextViewer textViewer;

    private IDocument document;

    public CompositeUndoManager(JETEditor jetEditor, int undoLevel)
    {
      this.jetEditor = jetEditor;
      this.undoLevel = undoLevel;
    }

    protected SharedTextViewerUndoManager getUndoManager()
    {
      return managers.get(document);
    }

    public IUndoContext getUndoContext()
    {
      return undoContext;
    }

    public void connect(ITextViewer textViewer)
    {
      if (this.textViewer == null)
      {
        textViewer.addTextInputListener(this);
      }

      this.textViewer = textViewer;

      inputDocumentAboutToBeChanged(this.document, textViewer.getDocument());
    }

    public void disconnect()
    {
      textViewer.removeTextInputListener(this);
      textViewer = null;
      document = null;

      for (SharedTextViewerUndoManager undoManager : managers.values())
      {
        undoManager.disconnect();
      }

      managers.clear();
    }

    public void reset()
    {
      // This is called when switching documents and we don't want to lose our undo history for each document so don't do anything.
    }

    public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput)
    {
      SharedTextViewerUndoManager undoManager = getUndoManager();
      if (undoManager != null)
      {
        undoManager.removeListeners();
      }
    }

    public void inputDocumentChanged(IDocument oldInput, IDocument newInput)
    {
      this.document = newInput;
      SharedTextViewerUndoManager undoManager = getUndoManager();
      if (undoManager == null)
      {
        undoManager = new SharedTextViewerUndoManager(undoLevel, jetEditor, textViewer, document);
        managers.put(document, undoManager);
      }
      undoManager.addListeners();
    }

    public void beginCompoundChange()
    {
      if (compoundChange++ == 0)
      {
        for (SharedTextViewerUndoManager sharedTextViewerUndoManager : managers.values())
        {
          sharedTextViewerUndoManager.beginCompoundChange();
        }
      }
    }

    public void endCompoundChange()
    {
      if (--compoundChange == 0)
      {
        for (SharedTextViewerUndoManager sharedTextViewerUndoManager : managers.values())
        {
          sharedTextViewerUndoManager.endCompoundChange();
        }
      }
    }

    public void setMaximalUndoLevel(int undoLevel)
    {
      getUndoManager().setMaximalUndoLevel(undoLevel);
    }

    public boolean undoable()
    {
      return getUndoManager().undoable();
    }

    public boolean redoable()
    {
      return getUndoManager().redoable();
    }

    public void undo()
    {
      getUndoManager().undo();
    }

    public void redo()
    {
      getUndoManager().redo();
    }
  }

  static class SharedTextViewerUndoManager implements IUndoManager, IUndoManagerExtension, IDocumentUndoListener, KeyListener, MouseListener
  {
    private final JETEditor jetEditor;

    private final ITextViewer textViewer;

    private final IDocumentUndoManager documentUndoManager;

    private final IDocument document;

    private int undoLevel;

    public SharedTextViewerUndoManager(int undoLevel, JETEditor jetEditor, ITextViewer textViewer, IDocument document)
    {
      this.undoLevel = undoLevel;
      this.jetEditor = jetEditor;
      this.textViewer = textViewer;
      this.document = document;

      DocumentUndoManagerRegistry.connect(document);
      documentUndoManager = DocumentUndoManagerRegistry.getDocumentUndoManager(document);
      documentUndoManager.connect(this);

      setMaximalUndoLevel(undoLevel);

      documentUndoManager.addDocumentUndoListener(this);
    }

    public void beginCompoundChange()
    {
      documentUndoManager.beginCompoundChange();
    }

    public void endCompoundChange()
    {
      documentUndoManager.endCompoundChange();
    }

    public void addListeners()
    {
      StyledText text = textViewer.getTextWidget();
      if (text != null)
      {
        text.addMouseListener(this);
        text.addKeyListener(this);
      }
    }

    public void removeListeners()
    {
      StyledText text = textViewer.getTextWidget();
      if (text != null)
      {
        text.removeMouseListener(this);
        text.removeKeyListener(this);
      }
    }

    public void setMaximalUndoLevel(int newUndoLevel)
    {
      undoLevel = Math.max(0, newUndoLevel);
      documentUndoManager.setMaximalUndoLevel(undoLevel);
    }

    public void connect(ITextViewer newTextViewer)
    {
      // This is never called because we connect during construction.
    }

    public void disconnect()
    {
      removeListeners();
      documentUndoManager.disconnect(this);
      DocumentUndoManagerRegistry.disconnect(document);
      documentUndoManager.removeDocumentUndoListener(this);
    }

    public void reset()
    {
      documentUndoManager.reset();
    }

    public boolean redoable()
    {
      return documentUndoManager.redoable();
    }

    public boolean undoable()
    {
      return documentUndoManager.undoable();
    }

    public void redo()
    {
      try
      {
        documentUndoManager.redo();
      }
      catch (ExecutionException ex)
      {
        openErrorDialog("Redo Failed", ex);
      }
    }

    public void undo()
    {
      try
      {
        documentUndoManager.undo();
      }
      catch (ExecutionException ex)
      {
        openErrorDialog("Undo Failed", ex);
      }
    }

    private void selectAndReveal(int offset, int length)
    {
      jetEditor.selectAndReveal(document, offset, length);
    }

    public IUndoContext getUndoContext()
    {
      return documentUndoManager.getUndoContext();
    }

    private void openErrorDialog(final String title, final Exception ex)
    {
      Shell shell = null;
      StyledText st = textViewer.getTextWidget();
      if (st != null && !st.isDisposed())
      {
        shell = st.getShell();
      }

      if (Display.getCurrent() != null)
      {
        MessageDialog.openError(shell, title, ex.getLocalizedMessage());
      }
      else
      {
        Display display;
        final Shell finalShell = shell;
        if (finalShell != null)
        {
          display = finalShell.getDisplay();
        }
        else
        {
          display = Display.getDefault();
        }
        display.syncExec(new Runnable()
          {
            public void run()
            {
              MessageDialog.openError(finalShell, title, ex.getLocalizedMessage());
            }
          });
      }
    }

    public void mouseDoubleClick(MouseEvent event)
    {
    }

    public void mouseUp(MouseEvent event)
    {
    }

    public void mouseDown(MouseEvent event)
    {
      if (event.button == 1)
      {
        documentUndoManager.commit();
      }
    }

    public void keyReleased(KeyEvent event)
    {
    }

    public void keyPressed(KeyEvent event)
    {
      switch (event.keyCode)
      {
        case SWT.ARROW_UP:
        case SWT.ARROW_DOWN:
        case SWT.ARROW_LEFT:
        case SWT.ARROW_RIGHT:
        {
          documentUndoManager.commit();
          break;
        }
      }
    }

    public void documentUndoNotification(DocumentUndoEvent event)
    {
      int eventType = event.getEventType();
      if ((eventType & DocumentUndoEvent.ABOUT_TO_UNDO) != 0 || (eventType & DocumentUndoEvent.ABOUT_TO_REDO) != 0)
      {
        if (event.isCompound())
        {
          ((ITextViewerExtension)textViewer).setRedraw(false);
        }
      }
      else if (((eventType & DocumentUndoEvent.UNDONE) != 0) || ((eventType & DocumentUndoEvent.REDONE) != 0))
      {
        if (event.isCompound())
        {
          ((ITextViewerExtension)textViewer).setRedraw(true);
        }

        StyledText widget = textViewer.getTextWidget();
        if (widget != null && !widget.isDisposed() && widget.isFocusControl())
        {
          selectAndReveal(event.getOffset(), event.getText() == null ? 0 : event.getText().length());
        }
      }
    }
  }

  static class JETDamageRepairer extends DefaultDamagerRepairer
  {
    private final JETEditor jetEditor;

    private int capacity = 8;

    private int size = 0;

    private int[] offsets = new int [capacity];

    private JETToken[] tokens = new JETToken [capacity];

    public JETDamageRepairer(JETEditor jetEditor, ITokenScanner scanner)
    {
      super(scanner);
      this.jetEditor = jetEditor;
    }

    private void ensureCapacity(int capacity)
    {
      if (this.capacity < capacity)
      {
        int newCapacity = capacity << 1;
        int[] newOffsets = new int [newCapacity];
        JETToken[] newTokens = new JETToken [newCapacity];
        System.arraycopy(offsets, 0, newOffsets, 0, this.capacity);
        System.arraycopy(tokens, 0, newTokens, 0, this.capacity);

        this.offsets = newOffsets;
        this.tokens = newTokens;
        this.capacity = newCapacity;
      }
    }

    private void add(int offset, int length, JETToken token)
    {
      ensureCapacity(size + 2);
      tokens[size] = token;
      offsets[size] = offset;
      tokens[++size] = null;
      offsets[size] = offset + length;
    }

    @Override
    public void createPresentation(TextPresentation presentation, ITypedRegion region)
    {
      try
      {
        super.createPresentation(presentation, region);
      }
      finally
      {
        int[] offsets = new int [size + 1];
        JETToken[] tokens = new JETToken [size + 1];

        System.arraycopy(this.offsets, 0, offsets, 0, size + 1);
        System.arraycopy(this.tokens, 0, tokens, 0, size + 1);

        jetEditor.setTokenData(offsets, tokens);

        size = 0;
        this.offsets[0] = 0;
        this.offsets[1] = 0;
      }
    }

    @Override
    protected void addRange(TextPresentation presentation, int offset, int length, TextAttribute textAttribute)
    {
      if (textAttribute instanceof ColorManager.JETTextAttribute)
      {
        JETEditor.ColorManager.JETTextAttribute jetTextAttribute = (ColorManager.JETTextAttribute)textAttribute;
        JETToken token = jetTextAttribute.getToken();
        add(offset, length, token);

        int style = textAttribute.getStyle();
        int fontStyle = style & (SWT.ITALIC | SWT.BOLD | SWT.NORMAL);
        StyleRange styleRange = new StyleRange(offset, length, textAttribute.getForeground(), textAttribute.getBackground(), fontStyle);
        styleRange.strikeout = (style & TextAttribute.STRIKETHROUGH) != 0;
        styleRange.underline = (style & TextAttribute.UNDERLINE) != 0;
        styleRange.font = textAttribute.getFont();
        styleRange.data = token;
        styleRange.borderStyle = jetTextAttribute.getBorderStyle();
        if (styleRange.borderStyle != SWT.NONE)
        {
          styleRange.borderColor = styleRange.foreground;
        }

        presentation.addStyleRange(styleRange);
      }
    }
  }

  static class JETTokenRegion
  {
    private final JETToken token;

    private int offset;

    private int length;

    public JETTokenRegion(int offset, int length, JETToken token)
    {
      this.offset = offset;
      this.length = length;
      this.token = token;
    }

    public JETToken getToken()
    {
      return token;
    }

    public void shrinkToJava(IDocument document)
    {
      if (token == JETScriptletRule.TOKEN)
      {
        int delta = 0;

        try
        {
          while (Character.isWhitespace(document.getChar(offset + delta)))
          {
            ++delta;
          }
        }
        catch (BadLocationException exception)
        {
          // Should not happen.
        }

        offset += delta + 2;
        length -= delta + 2;
      }
      else if (token == JETExpressionRule.TOKEN)
      {
        offset += 3;
        length -= 5;
      }
    }

    public void expand()
    {
      --offset;
      length += 2;
    }

    public int getOffset()
    {
      return offset;
    }

    public void setOffset(int offset)
    {
      this.offset = offset;
    }

    public int getLength()
    {
      return length;
    }

    public void setLength(int length)
    {
      this.length = length;
    }
  }

  static class JETPresentationReconciler extends PresentationReconciler
  {
    private final JETEditor jetEditor;

    private IDocument document;

    public JETPresentationReconciler(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    @Override
    public TextPresentation createPresentation(IRegion damage, IDocument document)
    {
      if (document != this.document)
      {
        setDocument(document);
      }

      List<JETJavaItem> javaItems = null;
      List<JETRootItem> skippedItems = null;
      ITextViewerExtension5 javaViewer = null;
      StyledText javaStyledText = null;
      if (jetEditor.isJavaEditorInSync())
      {
        JETCompilationUnit compilerResult = jetEditor.getCompilationUnit();
        if (compilerResult != null)
        {
          ISourceViewer underlyingSourceViewer = jetEditor.getJavaEditor().getJavaSourceViewer();
          if (compilerResult.getJavaCompilationUnit().equals(underlyingSourceViewer.getDocument().get()))
          {
            int fileID = jetEditor.getFileID();
            int templateOffset = damage.getOffset();
            int templateLength = damage.getLength();
            javaItems = compilerResult.getJavaItems(fileID, templateOffset, templateLength);
            skippedItems = compilerResult.getSkippedItems(fileID, templateOffset, templateLength);
            javaStyledText = underlyingSourceViewer.getTextWidget();
            javaViewer = (ITextViewerExtension5)underlyingSourceViewer;
          }
        }
      }

      // Create the full presentation because we can only find tokens if we start from the start.
      // 
      Region fullRegion = new Region(0, document.getLength());
      TextPresentation fullTextPresentation = super.createPresentation(fullRegion, document);

      if (javaItems == null && damage.equals(fullRegion))
      {
        return fullTextPresentation;
      }

      // Filter these down to the ones within the actual damaged region because updating so many takes long.
      //
      TextPresentation textPresentation = new TextPresentation(damage, 1000);
      int offset = damage.getOffset();
      int end = offset + damage.getLength();
      for (Iterator<StyleRange> i = fullTextPresentation.getAllStyleRangeIterator(); i.hasNext();)
      {
        StyleRange styleRange = i.next();
        if (styleRange.start + styleRange.length >= offset && styleRange.start <= end)
        {
          if (javaItems == null)
          {
            textPresentation.addStyleRange(styleRange);
          }
          else
          {
            applySemanticStyle(textPresentation, styleRange, javaItems, skippedItems, javaStyledText, javaViewer);
          }
        }
      }

      return textPresentation;
    }

    private void applySemanticStyle(
      TextPresentation textPresentation,
      StyleRange styleRange,
      List<JETJavaItem> javaItems,
      List<JETRootItem> skippedItems,
      StyledText textWidget,
      ITextViewerExtension5 javaModelViewer)
    {
      IToken token = (IToken)styleRange.data;
      int start = styleRange.start;
      int end = styleRange.start + styleRange.length;
      for (JETRootItem jetRootItem : skippedItems)
      {
        if (jetRootItem.getStartOffset() < end && jetRootItem.getStopOffset() > start)
        {
          styleRange.strikeout = true;
          Color blendedColor = ColorManager.INSTANCE.getBlendedColor(styleRange.foreground, styleRange.background);
          styleRange.strikeoutColor = blendedColor;
          styleRange.foreground = blendedColor;
          break;
        }
      }

      Color defaultForeground = textWidget.getForeground();

      // Only do this work for scriptlets and expressions.
      if (token == JETScriptletRule.TOKEN || token == JETExpressionRule.TOKEN)
      {
        for (JETJavaItem javaItem : javaItems)
        {
          int delta = javaItem.getStartOffset() - start;
          if (delta >= 0 && javaItem.getStopOffset() <= end)
          {
            int javaOffset = javaItem.getJavaOffset();
            int javaLength = javaItem.getJavaLength();
            int javaWidgetOffset = javaModelViewer.modelOffset2WidgetOffset(javaOffset);

            StyleRange[] styleRanges = textWidget.getStyleRanges(javaWidgetOffset, javaLength);

            if (trace)
            {
              String text = javaItem.getText();
              String javaText = textWidget.getTextRange(javaWidgetOffset, javaLength);
              if (!text.equals(javaText))
              {
                if (trace)
                {
                  System.out.println("mismatched text when applying styles");
                }
                break;
              }
            }

            List<StyleRange> newStyleRanges = new ArrayList<StyleRange>();

            // Whatever text range appears before the start of the Java style range keeps the existing style.
            // This will definitely include the leading <%= or the leading <% and any pure whitespace before it.
            //
            StyleRange leadingNewStyleRanage = (StyleRange)styleRange.clone();
            leadingNewStyleRanage.length = delta;
            newStyleRanges.add(leadingNewStyleRanage);
            start += delta;

            int consumedLength = 0;
            for (StyleRange javaStyleRange : styleRanges)
            {
              StyleRange newStyleRange = (StyleRange)styleRange.clone();
              newStyleRange.start = start + consumedLength;
              newStyleRange.length = javaStyleRange.length;
              if (javaStyleRange.foreground == null || !javaStyleRange.foreground.equals(defaultForeground))
              {
                newStyleRange.foreground = javaStyleRange.foreground;
              }
              newStyleRange.foreground = newStyleRange.strikeout
                ? ColorManager.INSTANCE.getBlendedColor(newStyleRange.foreground, newStyleRange.background) : newStyleRange.foreground;
              newStyleRange.fontStyle = javaStyleRange.fontStyle;
              consumedLength += newStyleRange.length;
              newStyleRanges.add(newStyleRange);
            }

            // This will include the style range for the %>
            //
            StyleRange trailingNewStyleRange = (StyleRange)styleRange.clone();
            trailingNewStyleRange.start = start + consumedLength;
            trailingNewStyleRange.length = end - trailingNewStyleRange.start;
            newStyleRanges.add(trailingNewStyleRange);

            for (StyleRange newStyleRange : newStyleRanges)
            {
              textPresentation.addStyleRange(newStyleRange);
            }

            return;
          }
        }
      }

      // If we don't find a corresponding Java item, just handle it like normal.
      textPresentation.addStyleRange(styleRange);
    }

    protected void setDocument(IDocument document)
    {
      setDocumentToDamagers(document);
      setDocumentToRepairers(document);
      this.document = document;
    }
  }

  static class BracketInserter implements VerifyKeyListener
  {
    private final JETEditor jetEditor;

    private final ISelectionProvider jetSelectionProvider;

    public BracketInserter(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
      jetSelectionProvider = jetEditor.getSelectionProvider();
    }

    private boolean edit(ITextViewer jetSourceViewer, int offset, int length, String replacement, int selectionOffset)
    {
      try
      {
        IDocument document = jetSourceViewer.getDocument();
        document.replace(offset, length, replacement);
        jetSourceViewer.setSelectedRange(selectionOffset, 0);
        return false;
      }
      catch (BadLocationException exception)
      {
        return true;
      }
    }

    public void verifyKey(VerifyEvent event)
    {
      if (event.doit && jetEditor.getInsertMode() == SMART_INSERT && !isMultilineSelection())
      {
        ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
        final Point selection = jetSourceViewer.getSelectedRange();
        final int offset = selection.x;
        final int length = selection.y;
        if (length == 0 && offset > 0)
        {
          if (event.character == '%')
          {
            JETToken tokenAtSelection = jetEditor.getTokenAtSelection(0);
            JETToken tokenBeforeSelection = jetEditor.getTokenAtSelection(-1);
            if (tokenAtSelection != null && tokenAtSelection.getBaseToken() == JETContentRule.TOKEN
                || tokenBeforeSelection != null && tokenBeforeSelection.getBaseToken() == JETContentRule.TOKEN)
            {
              String text = jetSourceViewer.getTextWidget().getTextRange(offset - 1, 1);
              if ("<".equals(text))
              {
                event.doit = edit(jetSourceViewer, offset, 0, "%%>", offset + 1);
              }
            }
          }
          else if (event.character == '-')
          {
            JETToken token = jetEditor.getTokenAt(offset);
            if (token == JETScriptletRule.TOKEN)
            {
              IDocument document = jetSourceViewer.getDocument();
              try
              {
                if ("<%%>".equals(document.get(offset - 2, 4)))
                {
                  event.doit = edit(jetSourceViewer, offset, 0, "--", offset + 1);
                }
              }
              catch (BadLocationException e)
              {
              }
            }
          }
          else if (event.character == '>')
          {
            JETToken tokenAtSelection = jetEditor.getTokenAtSelection(0);
            if (tokenAtSelection == JETScriptletRule.TOKEN)
            {
              IDocument document = jetSourceViewer.getDocument();
              try
              {
                char character = document.getChar(offset - 1);
                if (character == '%')
                {
                  int documentLength = document.getLength();
                  StringBuilder additionalWhiteSpace = new StringBuilder();
                  for (int i = offset; i < documentLength; ++i)
                  {
                    character = document.getChar(i);
                    if (!Character.isWhitespace(character))
                    {
                      // {
                      if (character != '}')
                      {
                        additionalWhiteSpace.setLength(0);
                      }
                      break;
                    }
                    additionalWhiteSpace.append(character);
                  }

                  event.doit = edit(jetSourceViewer, offset, additionalWhiteSpace.length(), ">" + additionalWhiteSpace + "<%", offset + 1);
                }
              }
              catch (BadLocationException e)
              {
              }
            }
          }
          else if (event.keyCode == 0x8)
          {
            JETTokenRegion tokenRegion = jetEditor.getTokenRegionAt(offset);
            if (tokenRegion != null)
            {
              JETToken token = tokenRegion.getToken();
              if (token == JETCommentRule.TOKEN)
              {
                if (offset - tokenRegion.getOffset() == 3 && tokenRegion.getLength() == 6)
                {
                  event.doit = edit(jetSourceViewer, offset - 1, 2, "", offset - 1);
                }
              }
              else if (token == JETScriptletRule.TOKEN)
              {
                if (offset - tokenRegion.getOffset() == 2 && tokenRegion.getLength() == 4)
                {
                  event.doit = edit(jetSourceViewer, offset - 1, 3, "", offset - 1);
                }
              }
            }
          }
        }
      }
    }

    private boolean isMultilineSelection()
    {
      ISelection selection = jetSelectionProvider.getSelection();
      if (selection instanceof ITextSelection)
      {
        ITextSelection ts = (ITextSelection)selection;
        return ts.getStartLine() != ts.getEndLine();
      }
      return false;
    }
  }

  static final class JETToken extends Token
  {
    private final String type;

    private final int textStyle;

    private final int borderStyle;

    private final JETToken baseToken;

    public JETToken(String type)
    {
      this(type, SWT.NONE, SWT.NONE);
    }

    public JETToken(String type, int textStyle, int borderStyle)
    {
      super(null);
      this.type = type;
      this.textStyle = textStyle;
      this.borderStyle = borderStyle;
      this.baseToken = this;
      ColorManager.INSTANCE.register(this);
    }

    public JETToken(JETToken baseToken, String type, int textStyle)
    {
      this(baseToken, type, textStyle, SWT.NONE);
    }

    public JETToken(JETToken baseToken, String type, int textStyle, int borderStyle)
    {
      super(null);
      this.type = type + '.' + baseToken.getType();
      this.textStyle = textStyle;
      this.baseToken = baseToken;
      this.borderStyle = borderStyle;
      ColorManager.INSTANCE.register(this);
    }

    public final String getType()
    {
      return type;
    }

    public final JETToken getBaseToken()
    {
      return baseToken;
    }

    public final int getTextStyle()
    {
      return textStyle;
    }

    public final int getBorderStyle()
    {
      return borderStyle;
    }

    public final void setData(TextAttribute textAttribute)
    {
      super.setData(textAttribute);
    }

    @Override
    public final void setData(Object data)
    {
      super.setData((TextAttribute)data);
    }

    @Override
    public final String toString()
    {
      return "JETToken:" + type;
    }

    public final IRegion match(Point tokenRange, int offset)
    {
      int prefixLength = -1;
      if (type.equals("scriptlet"))
      {
        prefixLength = 2;
      }
      else if (type.equals("expression") || type.equals("directive") || type.equals("comment"))
      {
        prefixLength = 3;
      }

      if (prefixLength != -1)
      {
        if (offset == tokenRange.x + tokenRange.y || offset == tokenRange.x + 1)
        {
          return new Region(tokenRange.x, tokenRange.y);
        }

        if (offset == tokenRange.x + tokenRange.y - 1 || offset == tokenRange.x + 2)
        {
          return new Region(tokenRange.x + 1, tokenRange.y - 2);
        }

        if (prefixLength == 3 && (offset == tokenRange.x + tokenRange.y - 1 || offset == tokenRange.x + 3))
        {
          return new Region(tokenRange.x + 2, tokenRange.y - 3);
        }
      }

      return null;
    }
  }

  static abstract class JETRule
  {
    private final JETToken successToken;

    private final char[] prefix;

    private int count;

    public JETRule(JETToken successToken, char[] prefix)
    {
      this.successToken = successToken;
      this.prefix = prefix;
    }

    protected int getCount()
    {
      return count;
    }

    public final JETToken getSuccessToken()
    {
      return successToken;
    }

    protected boolean scanForStart(ICharacterScanner scanner)
    {
      for (int i = 0; i < prefix.length; ++i)
      {
        if (prefix[i] != read(scanner))
        {
          return false;
        }
      }
      return true;
    }

    protected boolean scanForEnd(ICharacterScanner scanner)
    {
      for (int character = read(scanner); character != ICharacterScanner.EOF; character = read(scanner))
      {
        if (character == '%')
        {
          if (read(scanner) == '>')
          {
            return true;
          }

          unread(scanner);
        }
      }

      return false;
    }

    protected int read(ICharacterScanner scanner)
    {
      ++count;
      int read = scanner.read();

      if (trace)
      {
        if (read == ICharacterScanner.EOF)
        {
          System.out.print("'eof'");
        }
        else if (read == ' ')
        {
          System.out.print("~");
        }
        else if (read == '\n')
        {
          System.out.print("\\n");
        }
        else if (read == '\r')
        {
          System.out.print("\\r");
        }
        else
        {
          System.out.print((char)read);
        }
      }

      return read;
    }

    protected void unread(ICharacterScanner scanner)
    {
      --count;
      scanner.unread();
    }

    protected void unreadAll(ICharacterScanner scanner)
    {
      while (count-- > 0)
      {
        scanner.unread();
      }
      count = 0;
    }

    protected boolean isGreedy()
    {
      return true;
    }

    protected void skipLeading(ICharacterScanner scanner)
    {
      if (trace)
      {
        System.out.println("-----------");
      }

      if (isGreedy())
      {
        for (int read = read(scanner); read == ' ' || read == '\t'; read = read(scanner))
        {
        }

        unread(scanner);
      }
    }

    public final IToken evaluate(ICharacterScanner scanner)
    {
      try
      {
        return doEvaluate(scanner);
      }
      finally
      {
        count = 0;
      }
    }

    protected IToken doEvaluate(ICharacterScanner scanner)
    {
      skipLeading(scanner);
      if (scanForStart(scanner))
      {
        if (scanForEnd(scanner))
        {
          return getSuccessToken();
        }
      }

      unreadAll(scanner);

      return Token.UNDEFINED;
    }
  }

  static class JETDirectiveRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char []{ '<', '%', '@' };

    public static final JETToken TOKEN = new JETToken("directive");

    @Override
    protected boolean isGreedy()
    {
      return false;
    }

    public JETDirectiveRule()
    {
      super(TOKEN, PREFIX);
    }
  }

  static class JETScriptletRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char []{ '<', '%' };

    public static final JETToken TOKEN = new JETToken("scriptlet");

    public JETScriptletRule()
    {
      super(TOKEN, PREFIX);
    }

    @Override
    protected boolean scanForStart(ICharacterScanner scanner)
    {
      if (super.scanForStart(scanner))
      {
        int read = read(scanner);
        unread(scanner);
        if (read == '@' || read == '=' || read == '-')
        {
          return false;
        }
        else
        {
          return true;
        }
      }
      else
      {
        return false;
      }
    }
  }

  static class JETCommentRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char []{ '<', '%', '-' };

    public static final JETToken TOKEN = new JETToken("comment");

    public JETCommentRule()
    {
      super(TOKEN, PREFIX);
    }

    @Override
    protected boolean scanForEnd(ICharacterScanner scanner)
    {
      for (int character = read(scanner); character != ICharacterScanner.EOF; character = read(scanner))
      {
        if (character == '-')
        {
          if (read(scanner) == '%')
          {
            if (read(scanner) == '>')
            {
              return true;
            }

            unread(scanner);
          }
          else
          {
            unread(scanner);
          }
        }
      }

      return false;
    }
  }

  static class JETExpressionRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char []{ '<', '%', '=' };

    public static final JETToken TOKEN = new JETToken("expression");

    public JETExpressionRule()
    {
      super(TOKEN, PREFIX);
    }

    @Override
    protected boolean isGreedy()
    {
      return false;
    }
  }

  static class JETContentRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char [0];

    public static final JETToken TOKEN = new JETToken("content");

    public JETContentRule()
    {
      super(TOKEN, PREFIX);
    }

    @Override
    protected IToken doEvaluate(ICharacterScanner scanner)
    {
      int trailingWhitespaceCount = 0;
      for (int read = read(scanner); read != ICharacterScanner.EOF; read = read(scanner))
      {
        if (read == '<')
        {
          if (read(scanner) == '%')
          {
            unread(scanner);
            unread(scanner);
            if (getCount() == 0)
            {
              return Token.UNDEFINED;
            }
            else
            {
              return getSuccessToken();
            }
          }
        }
        else if (read == '\n')
        {
          if (trailingWhitespaceCount != 0)
          {
            for (int i = 0; i <= trailingWhitespaceCount; ++i)
            {
              unread(scanner);
            }

            return getCount() == 0 ? Token.UNDEFINED : getSuccessToken();
          }
          else
          {
            return getSuccessToken();
          }
        }
        else if (read == '\r')
        {
          if (trailingWhitespaceCount != 0)
          {
            ++trailingWhitespaceCount;
          }
        }
        else if (read == ' ' || read == '\t')
        {
          ++trailingWhitespaceCount;
        }
        else
        {
          trailingWhitespaceCount = 0;
        }
      }

      if (getCount() == 1)
      {
        return Token.EOF;
      }
      else
      {
        if (trailingWhitespaceCount != 0)
        {
          for (int i = 0; i <= trailingWhitespaceCount; ++i)
          {
            unread(scanner);
          }
        }
        return getCount() == 0 ? Token.UNDEFINED : getSuccessToken();
      }
    }
  }

  static class JETTrailingWhitespaceContentRule extends JETRule implements IRule
  {
    private static final char[] PREFIX = new char [0];

    public static final JETToken TOKEN = new JETToken(JETContentRule.TOKEN, "trailing-whitespace-content", SWT.NONE, SWT.BORDER_SOLID);

    public JETTrailingWhitespaceContentRule()
    {
      super(TOKEN, PREFIX);
    }

    @Override
    protected IToken doEvaluate(ICharacterScanner scanner)
    {
      for (int read = read(scanner); read != ICharacterScanner.EOF; read = read(scanner))
      {
        if (read == '\n')
        {
          return getSuccessToken();
        }
        else if (read != ' ' && read != '\t' && read != '\r')
        {
          unreadAll(scanner);
          return Token.UNDEFINED;
        }
      }

      return getCount() == 1 ? Token.EOF : getSuccessToken();
    }
  }

  static class JETBaseErrorRule extends JETRule implements IRule
  {
    public JETBaseErrorRule(JETToken successToken, char[] prefix)
    {
      super(successToken, prefix);
    }

    @Override
    protected IToken doEvaluate(ICharacterScanner scanner)
    {
      if (scanForStart(scanner))
      {
        for (int read = read(scanner); read != ICharacterScanner.EOF; read = read(scanner))
        {
        }

        return getSuccessToken();
      }

      if (read(scanner) == ICharacterScanner.EOF)
      {
        return Token.EOF;
      }
      else
      {
        unreadAll(scanner);
        return Token.UNDEFINED;
      }
    }
  }

  static class JETScriptletErrorRule extends JETBaseErrorRule
  {
    public static final JETToken TOKEN = new JETToken(JETScriptletRule.TOKEN, "error", TextAttribute.STRIKETHROUGH);

    public JETScriptletErrorRule()
    {
      super(TOKEN, JETScriptletRule.PREFIX);
    }
  }

  static class JETExpressionErrorRule extends JETBaseErrorRule
  {
    public static final JETToken TOKEN = new JETToken(JETExpressionRule.TOKEN, "error", TextAttribute.STRIKETHROUGH);

    public JETExpressionErrorRule()
    {
      super(TOKEN, JETExpressionRule.PREFIX);
    }
  }

  static class JETCommentErrorRule extends JETBaseErrorRule
  {
    public static final JETToken TOKEN = new JETToken(JETCommentRule.TOKEN, "error", TextAttribute.STRIKETHROUGH);

    public JETCommentErrorRule()
    {
      super(TOKEN, JETCommentRule.PREFIX);
    }
  }

  static class JETDirectiveErrorRule extends JETBaseErrorRule
  {
    public static final JETToken TOKEN = new JETToken(JETDirectiveRule.TOKEN, "error", TextAttribute.STRIKETHROUGH);

    public JETDirectiveErrorRule()
    {
      super(TOKEN, JETDirectiveRule.PREFIX);
    }
  }

  @SuppressWarnings("restriction")
  static class JETBreadcrumbViewer extends org.eclipse.jdt.internal.ui.javaeditor.breadcrumb.BreadcrumbViewer
  {
    public JETBreadcrumbViewer(Composite parent, int style)
    {
      super(parent, style);

      addDoubleClickListener(new IDoubleClickListener()
        {
          public void doubleClick(DoubleClickEvent event)
          {
            Object element = ((IStructuredSelection)event.getSelection()).getFirstElement();
            Widget item = findItem(((ITreeContentProvider)getContentProvider()).getParent(element));
            if (item != null)
            {
              try
              {
                Method openDropDownMenuMethod = item.getClass().getDeclaredMethod("openDropDownMenu");
                openDropDownMenuMethod.setAccessible(true);
                openDropDownMenuMethod.invoke(item);
              }
              catch (Exception ex)
              {
                // Ignore.
              }
            }
          }
        });
    }

    @Override
    protected void configureDropDownViewer(TreeViewer viewer, Object input)
    {
    }

    @Override
    public Control getControl()
    {
      // Ensure the callers don't get warnings about restricted access.
      return super.getControl();
    }
  }

  static class JETTextSelectionNavigationLocation extends NavigationLocation
  {
    private static final String TAG_X = "x";

    private static final String TAG_Y = "y";

    private static final String TAG_DOCUMENT_ID = "document_id";

    private static final String TAG_INFO = "info";

    private static final String INFO_DELETED = "deleted";

    private static final String INFO_NOT_DELETED = "not_deleted";

    private static final String CATEGORY = "__navigation_" + JETTextSelectionNavigationLocation.class.hashCode();

    private static final IPositionUpdater POSITION_UPDATER = new DefaultPositionUpdater(CATEGORY);

    private Position position;

    private String documentID;

    private IDocument document;

    private Position savedPosition;

    public JETTextSelectionNavigationLocation(JETEditor jetEditor, boolean initialize)
    {
      super(jetEditor);

      if (initialize)
      {
        ITextSelection selection = (ITextSelection)jetEditor.getSelectionProvider().getSelection();
        IDocument document = getDocument(jetEditor);
        Position position = new Position(selection.getOffset(), selection.getLength());
        if (installOnDocument(document, position, CATEGORY, POSITION_UPDATER))
        {
          this.document = document;
          this.documentID = getDocumentID(jetEditor);
          Assert.isNotNull(this.documentID, "The document ID must be specified");
          this.position = position;
          if (!jetEditor.isDirty())
          {
            savedPosition = new Position(position.offset, position.length);
          }
        }
      }
    }

    public String getDocumentID()
    {
      return documentID;
    }

    private String getDocumentID(JETEditor jetEditor)
    {
      return jetEditor.getDocumentManager().getDocumentID();
    }

    private IDocument getDocument(JETEditor jetEditor)
    {
      return jetEditor.getSourceViewer().getDocument();
    }

    @Override
    public void dispose()
    {
      free();
      super.dispose();
    }

    private void free()
    {
      uninstallFromDocument(document, position, CATEGORY, POSITION_UPDATER);
      document = null;
      position = null;
      savedPosition = null;
      documentID = null;

    }

    @Override
    public void releaseState()
    {
      free();
      super.releaseState();
    }

    public boolean mergeInto(INavigationLocation location)
    {
      if (location == null || location.getClass() != getClass())
      {
        return false;
      }

      JETTextSelectionNavigationLocation jetLocation = (JETTextSelectionNavigationLocation)location;
      if (!jetLocation.documentID.equals(documentID))
      {
        return false;
      }

      if (position == null || position.isDeleted || document == null)
      {
        return true;
      }

      if (jetLocation.position == null || jetLocation.position.isDeleted)
      {
        uninstallFromDocument(document, position, CATEGORY, POSITION_UPDATER);
        jetLocation.document = document;
        jetLocation.position = position;
        jetLocation.savedPosition = savedPosition;
        jetLocation.documentID = documentID;
        return true;
      }

      if (jetLocation.document == document)
      {
        if (jetLocation.position.overlapsWith(position.offset, position.length) || position.offset + position.length == jetLocation.position.offset
            || jetLocation.position.offset + jetLocation.position.length == position.offset)
        {
          jetLocation.position.offset = position.offset;
          jetLocation.position.length = position.length;
          return true;
        }
      }

      return false;
    }

    public void restoreLocation()
    {
      if (position != null && !position.isDeleted)
      {
        IEditorPart part = getEditorPart();
        if (part instanceof JETEditor)
        {
          JETEditor editor = (JETEditor)getEditorPart();
          editor.selectAndReveal(this, position.offset, position.length);
        }
      }
    }

    public void saveState(IMemento memento)
    {
      if (savedPosition != null)
      {
        memento.putInteger(TAG_X, savedPosition.offset);
        memento.putInteger(TAG_Y, savedPosition.length);
        memento.putString(TAG_INFO, (savedPosition.isDeleted ? INFO_DELETED : INFO_NOT_DELETED));
        memento.putString(TAG_DOCUMENT_ID, documentID);
      }
    }

    public void restoreState(IMemento memento)
    {
      IEditorPart part = getEditorPart();
      if (part instanceof JETEditor)
      {
        documentID = memento.getString(TAG_DOCUMENT_ID);

        Integer offset = memento.getInteger(TAG_X);
        Integer length = memento.getInteger(TAG_Y);
        String deleted = memento.getString(TAG_INFO);

        if (offset != null && length != null)
        {
          Position position = new Position(offset.intValue(), length.intValue());
          this.position = position;
          if (deleted != null)
          {
            position.isDeleted = INFO_DELETED.equals(deleted) ? true : false;
          }
        }
      }
    }

    public void restoreDocument(JETEditor jetEditor, IDocument document)
    {
      this.document = document;
      if (installOnDocument(document, position, CATEGORY, POSITION_UPDATER))
      {
        if (!jetEditor.isDirty())
        {
          savedPosition = new Position(position.offset, position.length);
        }
      }
    }

    public void partSaved(IEditorPart part)
    {
      savedPosition = position == null || position.isDeleted() ? null : new Position(position.offset, position.length);
    }

    private boolean samePosition(JETEditor jetEditor)
    {
      if (position == null)
      {
        return true;
      }

      if (position.isDeleted)
      {
        return false;
      }

      if (!getDocumentID(jetEditor).equals(documentID))
      {
        return false;
      }

      ITextSelection textSelection = (ITextSelection)jetEditor.getSelectionProvider().getSelection();
      if (textSelection.getOffset() == position.offset && textSelection.getLength() == position.length)
      {
        String text = textSelection.getText();
        if (text != null)
        {
          try
          {
            return text.equals(document.get(position.offset, position.length));
          }
          catch (BadLocationException exception)
          {
          }
        }
      }

      return false;
    }

    public void update()
    {
      IEditorPart part = getEditorPart();
      if (part instanceof JETEditor)
      {
        JETEditor textEditor = (JETEditor)part;

        if (!samePosition(textEditor))
        {
          ITextSelection selection = (ITextSelection)textEditor.getSelectionProvider().getSelection();
          if (selection.getOffset() != 0 || selection.getLength() != 0)
          {
            position.offset = selection.getOffset();
            position.length = selection.getLength();
            position.isDeleted = false;

            if (!part.isDirty())
            {
              savedPosition = new Position(position.offset, position.length);
            }
          }
        }
      }
    }

    @Override
    public String toString()
    {
      return "Selection<" + position + ">";
    }
  }

  static class JETDynamicCompilerJob extends Job implements IDocumentListener
  {
    private final JETEditor jetEditor;

    private final IFile file;

    private volatile boolean disabled;

    public JETDynamicCompilerJob(JETEditor jetEditor, IFile file)
    {
      super("JET Dynamic Compiler");
      setSystem(true);
      this.jetEditor = jetEditor;
      this.file = file;
    }

    public void setDisabled(boolean disabled)
    {
      this.disabled = disabled;
      if (disabled)
      {
        cancel();
      }
      else
      {
        documentChanged(null);
      }
    }

    @Override
    protected IStatus run(IProgressMonitor monitor)
    {
      if (!disabled)
      {
        try
        {
          final WorkingCopyCompilationMonitor compilationMonitor = new WorkingCopyCompilationMonitor();
          JETCompileTemplateOperation jetCompileTemplateOperation = new JETCompileTemplateOperation(file, compilationMonitor)
            {
              @Override
              public void run(IProgressMonitor progressMonitor) throws CoreException
              {
                if (files.isEmpty())
                {
                  files.add(file);
                }

                super.run(progressMonitor);
              }
            };

          long startTime = System.currentTimeMillis();
          jetCompileTemplateOperation.run(monitor);
          if (!monitor.isCanceled())
          {
            final JETCompilationUnit compilerResult = compilationMonitor.getResult();
            if (compilerResult != null)
            {
              JETNature nature = jetEditor.getJETNature();

              IContainer sourceContainer = nature.getJavaSourceContainer();
              IProject project = sourceContainer.getProject();
              IJavaProject javaProject = JavaCore.create(project);

              String className = compilerResult.getClassName();
              final IFile javaFile = sourceContainer.getFile(new Path(className.replace('.', '/') + ".java"));

              ICompilationUnit compilationUnit = JavaCore.createCompilationUnitFrom(javaFile);
              LocalWorkingCopy localWorkingCopy = new LocalWorkingCopy(compilerResult.getJavaCompilationUnit());
              ICompilationUnit workingCopy = compilationUnit.getWorkingCopy(localWorkingCopy, null);

              ASTParser astParser = CodeGenUtil.EclipseUtil.newASTParser(true);
              String fileExtension = file.getFileExtension();
              if (fileExtension != null && fileExtension.endsWith("jet"))
              {
                astParser.setResolveBindings(true);
              }
              astParser.setProject(javaProject);

              ASTRequestor astRequestor = new ASTRequestor()
                {
                  @Override
                  public void acceptAST(ICompilationUnit sourceUnit, CompilationUnit compiledUnit)
                  {
                    IProblem[] problems = compiledUnit.getProblems();
                    JETCompilerResult jetCompilerResult = new JETCompilerResult(javaFile, compilerResult, Arrays.asList(problems), compilationMonitor.getException());
                    handleJavaResult(jetCompilerResult);
                  }
                };

              astParser.createASTs(new ICompilationUnit []{ workingCopy }, new String [0], astRequestor, null);
            }
            else if (compilationMonitor.getException() != null)
            {
              JETCompilerResult jetCompilerResult = new JETCompilerResult(compilationMonitor.getException());
              handleJavaResult(jetCompilerResult);
            }
          }

          long stop = System.currentTimeMillis();
          if (trace)
          {
            System.out.println("elapsed=" + (stop - startTime));
          }
        }
        catch (CoreException exception)
        {
          CodeGenUIPlugin.getPlugin().log(exception);
        }
      }

      return Status.OK_STATUS;
    }

    private void handleJavaResult(final JETCompilerResult jetCompilerResult)
    {
      if (!disabled)
      {
        jetEditor.handleCompilerResult(jetCompilerResult);
      }
    }

    public void documentAboutToBeChanged(DocumentEvent event)
    {
      if (!disabled)
      {
        cancel();
      }
    }

    public void documentChanged(DocumentEvent event)
    {
      if (!disabled)
      {
        jetEditor.resetExpectedModificationStamp();
        schedule(100);
      }
    }
  }

  static class JETCompilerResult
  {
    private final IFile javaFile;

    private final JETCompilationUnit compilationUnit;

    private final List<IProblem> javaProblems;

    private final JETException jetException;

    private final Map<Integer, List<JETProblemAnnotation>> problemAnnotations = new HashMap<Integer, List<JETProblemAnnotation>>();

    public JETCompilerResult(IFile javaFile, JETCompilationUnit compilationUnit, List<IProblem> javaProblems, JETException jetException)
    {
      this.javaFile = javaFile;
      this.compilationUnit = compilationUnit;
      this.javaProblems = javaProblems;
      this.jetException = jetException;
    }

    public JETCompilerResult(JETException jetException)
    {
      this.javaFile = null;
      this.compilationUnit = null;
      this.javaProblems = Collections.emptyList();
      this.jetException = jetException;
    }

    public IFile getJavaFile()
    {
      return javaFile;
    }

    public JETException getJETException()
    {
      return jetException;
    }

    public List<IProblem> getJavaProblems()
    {
      return javaProblems;
    }

    public JETCompilationUnit getCompilationUnit()
    {
      return compilationUnit;
    }

    public List<JETProblemAnnotation> getProblem(JETItem jetItem)
    {
      int fileID = jetItem.getFileID();
      List<JETProblemAnnotation> allProblems = getProblems(fileID);
      if (!allProblems.isEmpty())
      {
        List<JETProblemAnnotation> result = new ArrayList<JETProblemAnnotation>();
        int startOffset = jetItem.getStartOffset();
        int stopOffset = jetItem.getStopOffset();
        for (JETProblemAnnotation problem : allProblems)
        {
          Position position = problem.getPosition();
          if (stopOffset > position.offset && startOffset < position.offset + position.length)
          {
            result.add(problem);
          }
        }
        return result;
      }
      else
      {
        return Collections.emptyList();
      }
    }

    public List<JETProblemAnnotation> getProblems(int fileID)
    {
      if (fileID < 0)
      {
        JETProblemAnnotation jetOrphanProblemAnnotation = new JETProblemAnnotation(IMarker.SEVERITY_WARNING, "This file is no longer included by the template", new Position(0, 0));
        return Collections.singletonList(jetOrphanProblemAnnotation);
      }
      else
      {
        List<JETProblemAnnotation> jetProblemAnnotations = problemAnnotations.get(fileID);
        if (jetProblemAnnotations == null)
        {
          jetProblemAnnotations = new ArrayList<JETProblemAnnotation>();
          JETException jetException = getJETException();
          if (jetException != null)
          {
            JETProblemAnnotation jetExceptionProblemAnnotation = getExceptionProblem(fileID, jetException);
            if (jetExceptionProblemAnnotation != null)
            {
              jetProblemAnnotations.add(jetExceptionProblemAnnotation);
            }
          }

          JETCompilationUnit result = getCompilationUnit();
          if (compilationUnit != null)
          {
            List<JETException> jetProblems = result.getProblems();
            for (JETException jetProblem : jetProblems)
            {
              JETProblemAnnotation jetExceptionProblemAnnotation = getExceptionProblem(fileID, jetProblem);
              if (jetExceptionProblemAnnotation != null)
              {
                jetProblemAnnotations.add(jetExceptionProblemAnnotation);
              }
            }

            List<IProblem> javaProblems = getJavaProblems();
            for (IProblem problem : javaProblems)
            {
              int start = problem.getSourceStart();
              int end = problem.getSourceEnd() + 1;
              int[] correspondingTemplatePoint = result.getClosestCorrespondingTemplatePoint(fileID, start, end == 0 ? 0 : end - start);
              if (correspondingTemplatePoint != null)
              {
                String message = problem.getMessage();
                JETProblemAnnotation jetProblemAnnotation = new JETProblemAnnotation(
                  problem.isError() ? IMarker.SEVERITY_ERROR : problem.isWarning() ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_INFO,
                  message,
                  new Position(correspondingTemplatePoint[0], correspondingTemplatePoint[1]));
                jetProblemAnnotations.add(jetProblemAnnotation);
              }
            }
          }
        }

        problemAnnotations.put(fileID, jetProblemAnnotations);

        return jetProblemAnnotations;
      }
    }

    protected JETProblemAnnotation getExceptionProblem(int fileID, JETException exception)
    {
      int offset = -1;
      int length = 0;
      boolean locatedInThisFile = false;
      for (JETMark start = exception.getStart(); start != null; start = start.getParentMark())
      {
        if (start.getFileId() == fileID)
        {
          offset = start.getCursor();
          JETMark stop = exception.getStop();
          locatedInThisFile = stop.getFileId() == fileID;
          if (locatedInThisFile)
          {
            length = stop.getCursor() - offset;
          }

          break;
        }
      }

      if (offset == -1)
      {
        String message = exception.getLocalizedMessage();
        int severity = exception.getDiagnostic().getSeverity();
        int problemSeverity = severity == Diagnostic.INFO ? IMarker.SEVERITY_INFO : severity == Diagnostic.WARNING ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_ERROR;
        JETProblemAnnotation jetProblemAnnotation = new JETProblemAnnotation(problemSeverity, message, new Position(0, length));
        return jetProblemAnnotation;
      }
      else
      {
        String message = exception.getLocalizedMessage();
        if (locatedInThisFile)
        {
          int index = message.indexOf(" in ");
          if (index != -1)
          {
            message = message.substring(0, index);
          }
        }

        int severity = exception.getDiagnostic().getSeverity();
        int problemSeverity = severity == Diagnostic.INFO ? IMarker.SEVERITY_INFO : severity == Diagnostic.WARNING ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_ERROR;
        JETProblemAnnotation jetProblemAnnotation = new JETProblemAnnotation(problemSeverity, message, new Position(offset, length));
        return jetProblemAnnotation;
      }
    }
  }

  static class VisibleCaretHandler extends FocusAdapter implements PaintListener
  {
    private final StyledText styledText;

    private final StyledText otherStyledText;

    public VisibleCaretHandler(StyledText styledText, StyledText otherStyledText)
    {
      this.styledText = styledText;
      this.otherStyledText = otherStyledText;
      styledText.addFocusListener(this);
      otherStyledText.addFocusListener(this);
      styledText.addPaintListener(this);
    }

    @Override
    public void focusGained(FocusEvent event)
    {
      Rectangle caretBounds = getCaretBounds();
      styledText.redraw(caretBounds.x, caretBounds.y, caretBounds.width, caretBounds.height, false);
    }

    @Override
    public void focusLost(FocusEvent event)
    {
      Rectangle caretBounds = getCaretBounds();
      styledText.redraw(caretBounds.x, caretBounds.y, caretBounds.width, caretBounds.height, false);
    }

    public void paintControl(PaintEvent event)
    {
      if (!styledText.isFocusControl() && otherStyledText.isFocusControl())
      {
        Color background = event.gc.getBackground();
        event.gc.setBackground(ColorManager.INSTANCE.getBlendedColor(ColorManager.INSTANCE.getForeground(JETDirectiveRule.TOKEN.getType()), background));
        Rectangle caretBounds = getCaretBounds();
        event.gc.fillRectangle(caretBounds);
        event.gc.setBackground(background);
      }
    }

    private Rectangle getCaretBounds()
    {
      return styledText.getCaret().getBounds();
    }
  }

  static class SelectEnclosingJETElementAction extends Action
  {
    private JETEditor jetEditor;

    public SelectEnclosingJETElementAction(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
    }

    @Override
    public void run()
    {
      ISourceViewer sourceViewer = jetEditor.getSourceViewer();
      Point selectedRange = sourceViewer.getSelectedRange();
      JETItem startItem = jetEditor.getJETItem(selectedRange.x, false);
      JETItem stopItem = jetEditor.getJETItem(selectedRange.x + selectedRange.y, false);

      if (startItem != null)
      {
        Point startRange = getRange(startItem);
        int offset = startRange.x;
        int end = startRange.x + startRange.y;
        if (stopItem != null)
        {
          Point stopRange = getRange(stopItem);
          end = stopRange.x + stopRange.y;
        }

        jetEditor.selectAndReveal(offset, end - offset);
      }
    }

    private Point getRange(JETItem jetItem)
    {
      if (jetItem instanceof JETScriptletItem || jetItem instanceof JETExpressionItem || jetItem instanceof JETCommentItem)
      {
        Point tokenRange = jetEditor.getTokenRangeAt(jetItem.getStartOffset());
        if (tokenRange != null)
        {
          return tokenRange;
        }
      }
      int start = jetItem.getStartOffset();
      int stop = jetItem.getStopOffset();
      return new Point(start, stop - start);
    }
  }

  static abstract class JETAbstractBaseAction extends Action
  {
    protected final JETEditor jetEditor;

    public JETAbstractBaseAction(JETEditor jetEditor, String text, ImageDescriptor imageDescriptor)
    {
      super(text, imageDescriptor);

      this.jetEditor = jetEditor;
    }

    @Override
    public void run()
    {
      SourceViewer jetSourceViewer = jetEditor.getJETSourceViewer();
      final IDocument jetDocument = jetSourceViewer.getDocument();

      final SourceViewer javaSourceViewer = jetEditor.getJavaSourceViewer();
      IDocument javaDocument = javaSourceViewer.getDocument();

      JETCompilationUnit compilationUnit = jetEditor.getCompilationUnit();
      List<JETJavaItem> javaItems = compilationUnit.getJavaItems(jetEditor.getFileID());
      List<TrackedPosition> jetPositions = new ArrayList<TrackedPosition>(javaItems.size());

      try
      {
        for (JETJavaItem jetJavaItem : javaItems)
        {
          if (jetJavaItem instanceof JETScriptletItem || jetJavaItem instanceof JETExpressionItem)
          {
            TrackedPosition jetPosition = new TrackedPosition(TrackedPosition.Type.JET);
            jetPosition.addToDocument(jetDocument);
            jetPosition.update(jetJavaItem);

            TrackedPosition javaPosition = new TrackedPosition(TrackedPosition.Type.JAVA);
            javaPosition.addToDocument(javaDocument);
            javaPosition.update(jetJavaItem);

            jetPosition.setOpposite(javaPosition);

            jetPositions.add(jetPosition);
          }
        }

        JavaDocumentTransaction javaDocumentTransaction = new JavaDocumentTransaction(jetEditor, jetPositions, isTransformBraces(), isIgnoreOutOfScopeChanges())
          {
            @Override
            protected void start()
            {
              DocumentRewriteSessionType documentRewriteSessionType = getDocumentRewriteSessionType();
              if (documentRewriteSessionType != null)
              {
                startDocumentRewriteSession(javaSourceViewer, documentRewriteSessionType, isRememberSelection());
              }

              JETAbstractBaseAction.this.start();
            }

            @Override
            protected void postCommit(List<TrackedPosition> jetPositions)
            {
              postProcess(jetDocument, jetPositions);
            }

            @Override
            protected void stop()
            {
              for (TrackedPosition jetPosition : jetPositions)
              {
                TrackedPosition javaPosition = jetPosition.getOpposite();
                jetPosition.dispose();
                javaPosition.dispose();
              }

              JETAbstractBaseAction.this.stop();

              DocumentRewriteSessionType documentRewriteSessionType = getDocumentRewriteSessionType();
              if (documentRewriteSessionType != null)
              {
                stopDocumentRewriteSession(javaSourceViewer, isRememberSelection());
              }
            }
          };

        javaDocumentTransaction.modify(javaDocument, new SneakyRunnable()
          {
            @Override
            public void execute() throws Exception
            {
              doRun();
            }
          });

        jetEditor.openDialog(getText().replace("&", "") + " Failure", javaDocumentTransaction.getStatus());
      }
      catch (Exception exception)
      {
        CodeGenUIPlugin.getPlugin().log(exception);
      }
    }

    protected DocumentRewriteSessionType getDocumentRewriteSessionType()
    {
      return null;
    }

    protected boolean isRememberSelection()
    {
      return getDocumentRewriteSessionType() != null;
    }

    protected boolean isTransformBraces()
    {
      return false;
    }

    boolean isIgnoreOutOfScopeChanges()
    {
      return false;
    }

    protected void start()
    {
    }

    protected abstract void doRun() throws Exception;

    protected void postProcess(IDocument jetDocument, List<TrackedPosition> jetPositions)
    {
    }

    protected void stop()
    {
    }
  }

  static class JETExtractLocalVariableAction extends JETAbstractBaseAction
  {
    private final IAction javaAction;

    public JETExtractLocalVariableAction(JETEditor jetEditor, IAction javaAction)
    {
      super(jetEditor, javaAction.getText(), javaAction.getImageDescriptor());

      this.javaAction = javaAction;

      setActionDefinitionId(javaAction.getActionDefinitionId());
    }

    @Override
    protected void doRun()
    {
      javaAction.run();
    }
  }

  static class JETRenameLocalVariableAction extends JETAbstractBaseAction
  {
    public JETRenameLocalVariableAction(JETEditor jetEditor)
    {
      super(jetEditor, "Re&name...", null);
      setActionDefinitionId(RENAME_COMMAND_ID);
    }

    @Override
    protected void doRun() throws Exception
    {
      IJavaElement[] selectedElements = jetEditor.getJavaEditor().getSelectedElements();
      if (selectedElements != null)
      {
        for (IJavaElement element : selectedElements)
        {
          if (element instanceof ILocalVariable)
          {
            ILocalVariable localVariable = (ILocalVariable)element;
            RenameSupport renameLocalVariableSupport = RenameSupport.create(localVariable, localVariable.getElementName(), RenameSupport.UPDATE_REFERENCES);
            renameLocalVariableSupport.openDialog(jetEditor.getSite().getShell());
            return;
          }
        }
      }

      throw new CoreException(new Status(IStatus.ERROR, CodeGenUIPlugin.getPlugin().getBundle().getSymbolicName(), "A local variable must be selected"));
    }
  }

  static class JETFormatAction extends JETAbstractBaseAction
  {
    public JETFormatAction(JETEditor jetEditor)
    {
      super(jetEditor, "&Format", null);
      setActionDefinitionId(FORMAT_COMMAND_ID);
    }

    @Override
    protected DocumentRewriteSessionType getDocumentRewriteSessionType()
    {
      return DocumentRewriteSessionType.UNRESTRICTED;
    }

    @Override
    boolean isIgnoreOutOfScopeChanges()
    {
      return true;
    }

    @Override
    protected void start()
    {
    }

    @Override
    protected void stop()
    {
      jetEditor.waitForCompilerResult(1000);
    }

    @Override
    protected void doRun() throws Exception
    {
      IJavaProject javaProject = JavaCore.create(jetEditor.getJETNature().getProject());
      Map<String, String> options = javaProject.getOptions(true);
      for (Map.Entry<String, String> entry : options.entrySet())
      {
        String key = entry.getKey();
        if (key.contains(".formatter.brace_position_for"))
        {
          entry.setValue(DefaultCodeFormatterConstants.END_OF_LINE);
        }
      }

      options.put(JavaCore.PLUGIN_ID + ".formatter.align_with_spaces", DefaultCodeFormatterConstants.TRUE);
      options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
      options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "2");
      options.put(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE, "2");
      options.put(DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT, DefaultCodeFormatterConstants.FALSE);
      options.put(DefaultCodeFormatterConstants.FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE, DefaultCodeFormatterConstants.TRUE);
      options.put(DefaultCodeFormatterConstants.FORMATTER_COMPACT_ELSE_IF, DefaultCodeFormatterConstants.TRUE);

      CodeFormatter codeFormatter = ToolFactory.createCodeFormatter(options);
      JavaEditor javaEditor = jetEditor.getJavaEditor();
      IDocument document = javaEditor.getJavaSourceViewer().getDocument();
      String source = document.get();
      TextEdit edit = ((CodeFormatter)codeFormatter).format(
        CodeFormatter.K_COMPILATION_UNIT | CodeFormatter.F_INCLUDE_COMMENTS,
        source,
        0,
        source.length(),
        0,
        TextUtilities.getDefaultLineDelimiter(document));
      if (edit != null)
      {
        edit.apply(document);
      }
    }

    @Override
    protected void postProcess(IDocument jetDocument, List<TrackedPosition> jetPositions)
    {
      IDocument javaDocument = jetEditor.getJavaSourceViewer().getDocument();

      MultiTextEdit multiTextEdit = new MultiTextEdit();
      List<JETRootItem> rootItems = JETParser.parseRootItems(jetDocument.get());
      for (JETRootItem jetRootItem : rootItems)
      {
        int start = jetRootItem.getStartOffset();
        int stop = jetRootItem.getStopOffset();
        if (jetRootItem instanceof JETScriptletItem)
        {
          JETScriptletItem jetScriptletItem = (JETScriptletItem)jetRootItem;
          String body = jetScriptletItem.getText();
          reformatScriptletBody(jetDocument, jetPositions, javaDocument, multiTextEdit, start, stop, body);
        }
        else if (jetRootItem instanceof JETDirectiveItem)
        {
          JETDirectiveItem jetDirectiveItem = (JETDirectiveItem)jetRootItem;
          String directive = jetDirectiveItem.getText();
          String directiveName = jetDirectiveItem.getNameItem().getText();
          if (!directiveName.isEmpty() && Character.isUpperCase(directiveName.codePointAt(0)))
          {
            multiTextEdit.addChild(new ReplaceEdit(start + 2, 0, " "));
            reformatScriptletBody(jetDocument, jetPositions, javaDocument, multiTextEdit, start + 2, stop - 2, directive.substring(2, directive.length() - 2));
          }
          else
          {
            reformatDirective(jetDocument, multiTextEdit, start, stop, directiveName, directive, jetDirectiveItem);
          }
        }
      }

      stripTrailingWhitespace(jetDocument, multiTextEdit);

      if (multiTextEdit.hasChildren())
      {
        try
        {
          multiTextEdit.apply(jetDocument);

          // As a second pass, to avoid overlapping edits, we correct the indentation of lines within the scriptlet bodies.
          multiTextEdit = new MultiTextEdit();
          rootItems = JETParser.parseRootItems(jetDocument.get());
          for (JETRootItem jetRootItem : rootItems)
          {
            if (jetRootItem instanceof JETScriptletItem)
            {
              int start = jetRootItem.getStartOffset();
              int stop = jetRootItem.getStopOffset();
              try
              {
                // Subsequent line starts within the scriptlet will simply have 2 spaces too much indentation.
                // Actually 4 because that's the generate method body's indentation,
                // but in order to line up with the start of the scriptlet, which has <% in it, it will have 2 too many.
                int lineOffset;
                for (int i = jetDocument.getLineOfOffset(start) + 1; (lineOffset = jetDocument.getLineOffset(i)) < stop; ++i)
                {
                  if (jetDocument.getChar(lineOffset) == ' ' && jetDocument.getChar(lineOffset + 1) == ' ')
                  {
                    multiTextEdit.addChild(new ReplaceEdit(lineOffset, 2, ""));
                  }
                }
              }
              catch (BadLocationException exception)
              {
              }
            }
          }

          if (multiTextEdit.hasChildren())
          {
            multiTextEdit.apply(jetDocument);
          }
        }
        catch (Exception exception)
        {
        }
      }
    }

    private static final Map<String, String[]> JET_DIRECTIVE_ORDERED_ATTRIBUTES = new HashMap<String, String[]>();

    static
    {
      JET_DIRECTIVE_ORDERED_ATTRIBUTES.put("jet", new String []{ "package", "class", "imports", "builder", "nlString", "minimize", "skeleton", "version" });
      JET_DIRECTIVE_ORDERED_ATTRIBUTES.put("include", new String []{ "file", "fail" });
    }

    private void reformatDirective(
      IDocument jetDocument,
      MultiTextEdit multiTextEdit,
      int start,
      int stop,
      String directiveName,
      String directive,
      JETDirectiveItem jetDirectiveItem)
    {
      StringBuilder result = new StringBuilder();
      result.append(directiveName);
      boolean isMultiLine = directive.contains("\n");
      String lineDelimiter = TextUtilities.getDefaultLineDelimiter(jetDocument);
      JETAttributeListItem attributes = jetDirectiveItem.getAttributes();
      List<JETAttributeItem> items = new ArrayList<JETAttributeItem>(attributes.getAttributes());
      String[] orderedAttributes = JET_DIRECTIVE_ORDERED_ATTRIBUTES.get(directiveName);
      if (orderedAttributes != null)
      {
        for (int i = orderedAttributes.length; --i >= 0;)
        {
          JETAttributeItem attribute = attributes.getAttribute(orderedAttributes[i]);
          if (items.remove(attribute))
          {
            items.add(0, attribute);
          }
        }
      }

      for (JETAttributeItem jetAttributeItem : items)
      {
        if (isMultiLine)
        {
          result.append(lineDelimiter);
          result.append("  ");
        }
        else if (result.length() != 0)
        {
          result.append(' ');
        }

        String nameText = jetAttributeItem.getNameToken().getText();
        result.append(nameText);
        result.append('=');

        JETTokenItem valueToken = jetAttributeItem.getValueToken();
        String valueText = valueToken.getText();
        if ("imports".equals(nameText))
        {
          char quote = valueText.length() == 0 ? '"' : valueText.charAt(0);

          boolean isMultiLineImport = valueText.contains("\n");

          if (isMultiLineImport)
          {
            result.append(lineDelimiter).append("    ");
          }

          result.append(quote);
          List<String> imports = sortImports(valueToken);
          int count = 0;
          for (String importedName : imports)
          {
            if (isMultiLineImport)
            {
              result.append(lineDelimiter).append("      ");
            }
            else if (count++ != 0)
            {
              result.append(' ');
            }

            result.append(importedName);
          }

          if (isMultiLineImport)
          {
            result.append(lineDelimiter).append("    ");
          }

          result.append(quote);
        }
        else
        {
          result.append(valueText);
        }
      }

      multiTextEdit.addChild(new ReplaceEdit(start + 3, stop - start - 5, result.toString()));
    }

    private static final Comparator<SegmentSequence> COMPARATOR = new Comparator<SegmentSequence>()
      {
        Comparator<String> comparator = CommonPlugin.INSTANCE.getComparator();

        public int compare(SegmentSequence o1, SegmentSequence o2)
        {
          int count1 = o1.segmentCount();
          int count2 = o2.segmentCount();

          for (int i = 0; i < count1 && i < count2; ++i)
          {
            int comparision = comparator.compare(o1.segment(i), o2.segment(i));
            if (comparision != 0)
            {
              return comparision;
            }
          }

          return count1 == count2 ? 0 : count1 < count2 ? -1 : 1;
        }
      };

    private List<String> sortImports(JETTokenItem imports)
    {
      Set<SegmentSequence> importedNames = new TreeSet<SegmentSequence>(COMPARATOR);
      for (JETValueElementItem jetValueElementItem : imports.getValueItem().getElements())
      {
        importedNames.add(SegmentSequence.create(".", jetValueElementItem.getText()));
      }

      List<String> result = new ArrayList<String>();
      for (SegmentSequence name : importedNames)
      {
        result.add(name.toString());
      }

      return result;
    }

    protected void stripTrailingWhitespace(IDocument jetDocument, MultiTextEdit multiTextEdit)
    {
      try
      {
        int numberOfLines = jetDocument.getNumberOfLines();
        for (int i = 0; i < numberOfLines; ++i)
        {
          int lineOffset = jetDocument.getLineOffset(i);
          int lineLength = jetDocument.getLineLength(i);
          String lineDelimiter = jetDocument.getLineDelimiter(i);
          int lineDelimiterLength = lineDelimiter == null ? 0 : lineDelimiter.length();
          int count = 0;
          for (int j = lineOffset + lineLength - lineDelimiterLength - 1; j >= 0; --j)
          {
            char character = jetDocument.getChar(j);
            if (character == ' ' || character == '\t')
            {
              ++count;
            }
            else
            {
              break;
            }
          }

          if (count > 0)
          {
            try
            {
              multiTextEdit.addChild(new ReplaceEdit(lineOffset + lineLength - lineDelimiterLength - count, count, ""));
            }
            catch (MalformedTreeException exception)
            {
              // These can and do happen because the directives are formatted to already eliminate trailing whitespace.
            }
          }
        }
      }
      catch (BadLocationException e)
      {
        // Can't happen.
      }
    }

    protected TrackedPosition getTrackedPosition(List<TrackedPosition> positions, int offset)
    {
      for (Position position : positions)
      {
        if (position.overlapsWith(offset, 0))
        {
          return (TrackedPosition)position;
        }
      }
      return null;
    }

    protected void reformatScriptletBody(
      IDocument jetDocument,
      List<TrackedPosition> positions,
      IDocument javaDocument,
      MultiTextEdit multiTextEdit,
      int start,
      int stop,
      String body)
    {
      // Trim any whitespace including the line feed at the end of the body.
      int trim = -1;
      int length = body.length();
      for (int i = length; --i >= 0;)
      {
        if (Character.isWhitespace(body.charAt(i)))
        {
          trim = i;
        }
        else
        {
          break;
        }
      }

      if (trim != -1)
      {
        multiTextEdit.addChild(new ReplaceEdit(start + trim, length - trim, ""));
      }

      // Compute the indentation for the scriptlet based on the indentation of the corresponding Java.
      TrackedPosition jetPosition = getTrackedPosition(positions, start);
      if (jetPosition != null)
      {
        TrackedPosition javaPosition = jetPosition.getOpposite();
        int jetIndentation = computeIndentation(jetDocument, jetPosition.offset - 2);
        if (jetIndentation != -1)
        {
          int javaIndentation = computeIndentation(javaDocument, javaPosition.offset);
          if (javaIndentation >= 4)
          {
            // The body of the generate method is expected to be at an indentation level of 4 spaces.
            int baseJavaIndentation = javaIndentation - 4;
            int delta = baseJavaIndentation - jetIndentation;
            if (delta > 0)
            {
              StringBuilder spaces = new StringBuilder();
              for (int i = 0; i < delta; ++i)
              {
                spaces.append(' ');
              }

              multiTextEdit.addChild(new ReplaceEdit(start - 2, 0, spaces.toString()));
            }
            else if (delta < 0)
            {
              multiTextEdit.addChild(new ReplaceEdit(start + delta - 2, -delta, ""));
            }
          }
        }
      }
    }

    protected int computeIndentation(IDocument document, int offset)
    {
      int indent = 0;
      for (int i = offset; --i >= 0;)
      {
        try
        {
          char character = document.getChar(i);
          if (character == ' ')
          {
            ++indent;
          }
          else if (character == '\n')
          {
            break;
          }
          else
          {
            return -1;
          }
        }
        catch (BadLocationException exception)
        {
        }
      }

      return indent;
    }
  }

  static class WorkingCopyCompilationMonitor extends JETCompileTemplateOperation.JETCompilationMonitor
  {
    @Override
    public InputStream openInputStream(String locationURI) throws JETException
    {
      URI uri = URI.createURI(locationURI);
      if (uri.isPlatformResource())
      {
        IPath fullPath = new Path(uri.toPlatformString(true));
        ITextFileBuffer buffer = ITextFileBufferManager.DEFAULT.getTextFileBuffer(fullPath, LocationKind.IFILE);
        if (buffer != null)
        {
          IDocument document = buffer.getDocument();
          String contents = document.get();
          try
          {
            return new ByteArrayInputStream(contents.getBytes("UTF-8"));
          }
          catch (UnsupportedEncodingException exception)
          {
            // UTF-8 is always supported.
          }
        }
      }

      return super.openInputStream(locationURI);
    }
  }

  static class LocalWorkingCopy extends WorkingCopyOwner
  {
    private String contents;

    public LocalWorkingCopy(String contents)
    {
      this.contents = contents;
    }

    @Override
    public IBuffer createBuffer(final ICompilationUnit workingCopy)
    {
      return new IBuffer()
        {
          public IOpenable getOwner()
          {
            return workingCopy;
          }

          public String getText(int offset, int length) throws IndexOutOfBoundsException
          {
            return contents.substring(offset, offset + length);
          }

          public int getLength()
          {
            return contents.length();
          }

          public String getContents()
          {
            return contents;
          }

          public char[] getCharacters()
          {
            return contents.toCharArray();
          }

          public char getChar(int position)
          {
            return contents.charAt(position);
          }

          public boolean isReadOnly()
          {
            return true;
          }

          public boolean isClosed()
          {
            return false;
          }

          public boolean hasUnsavedChanges()
          {
            return false;
          }

          public IResource getUnderlyingResource()
          {
            return null;
          }

          public void close()
          {
          }

          public void save(IProgressMonitor progress, boolean force) throws JavaModelException
          {
            throw new UnsupportedOperationException();
          }

          public void setContents(String contents)
          {
            throw new UnsupportedOperationException();
          }

          public void setContents(char[] contents)
          {
            throw new UnsupportedOperationException();
          }

          public void replace(int position, int length, String text)
          {
            throw new UnsupportedOperationException();
          }

          public void replace(int position, int length, char[] text)
          {
            throw new UnsupportedOperationException();
          }

          public void append(String text)
          {
            throw new UnsupportedOperationException();
          }

          public void append(char[] text)
          {
            throw new UnsupportedOperationException();
          }

          public void addBufferChangedListener(IBufferChangedListener listener)
          {
          }

          public void removeBufferChangedListener(IBufferChangedListener listener)
          {
          }
        };
    }
  }

  static final class StorageEditorInput extends PlatformObject implements IStorageEditorInput, IPathEditorInput, IURIEditorInput
  {
    private final URLStorage storage;

    public StorageEditorInput(URI uri)
    {
      this(uri, null, null);
    }

    public StorageEditorInput(URI uri, String contents, String encoding)
    {
      storage = new URLStorage(uri, contents, encoding == null ? "UTF-8" : encoding);
    }

    @Override
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public Object getAdapter(Class adapter)
    {
      return storage.getAdapter(adapter);
    }

    public boolean exists()
    {
      return storage.exists();
    }

    public ImageDescriptor getImageDescriptor()
    {
      IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();
      return registry.getImageDescriptor(storage.uri.fileExtension());
    }

    public String getName()
    {
      return storage.uri.lastSegment();
    }

    public IPersistableElement getPersistable()
    {
      return null;
    }

    public String getToolTipText()
    {
      return storage.uri.toString();
    }

    public IEncodedStorage getStorage() throws CoreException
    {
      return storage;
    }

    public java.net.URI getURI()
    {
      try
      {
        URI resolvedURI = JETNature.resolve(storage.uri);
        return new java.net.URI(resolvedURI.toString());
      }
      catch (URISyntaxException exception)
      {
        throw new RuntimeException(exception);
      }
    }

    public IPath getPath()
    {
      IPath path = storage.getFullPath();
      return path == null ? new Path("") : path;
    }

    public IFile getFile()
    {
      return (IFile)storage.getAdapter(IFile.class);
    }

    @Override
    public String toString()
    {
      return storage.toString();
    }

    @Override
    public int hashCode()
    {
      return storage.hashCode();
    }

    @Override
    public boolean equals(Object that)
    {
      if (this == that)
      {
        return true;
      }
      else if (that == null || that.getClass() != StorageEditorInput.class)
      {
        return false;
      }
      else
      {
        StorageEditorInput other = (StorageEditorInput)that;
        return storage == null ? other.storage == null : storage.equals(other.storage);
      }
    }

    private static final class URLStorage extends PlatformObject implements IEncodedStorage
    {
      private final URI uri;

      private final String contents;

      private final String encoding;

      public URLStorage(URI uri, String contents, String encoding)
      {
        this.uri = uri;
        this.contents = contents;
        this.encoding = encoding;
      }

      @Override
      @SuppressWarnings({ "unchecked", "rawtypes" })
      public Object getAdapter(Class adapter)
      {
        if (adapter == IFile.class)
        {
          IFile file = toFile(uri);
          if (file != null)
          {
            return file;
          }
        }

        return super.getAdapter(adapter);
      }

      public boolean exists()
      {
        try
        {
          if (contents == null)
          {
            getContents().close();
          }
          return true;
        }
        catch (Exception exception)
        {
          return false;
        }
      }

      public InputStream getContents() throws CoreException
      {
        try
        {
          if (contents == null)
          {
            return new URL(uri.toString()).openStream();
          }
          else
          {
            return new ByteArrayInputStream(contents.getBytes(encoding == null ? "UTF-8" : encoding));
          }
        }
        catch (Exception exception)
        {
          throw new CoreException(new Status(IStatus.ERROR, CodeGenPlugin.ID, exception.getLocalizedMessage(), exception));
        }
      }

      public IPath getFullPath()
      {
        if (uri.isPlatformResource())
        {
          return new Path(uri.toPlatformString(true));
        }

        if (uri.isFile())
        {
          return new Path(uri.toFileString());
        }

        return null;
      }

      public String getName()
      {
        return uri.lastSegment();
      }

      public boolean isReadOnly()
      {
        return true;
      }

      public String getCharset() throws CoreException
      {
        return encoding;
      }

      @Override
      public int hashCode()
      {
        return uri == null ? 0 : uri.hashCode();
      }

      @Override
      public boolean equals(Object that)
      {
        if (this == that)
        {
          return true;
        }
        else if (that == null || that.getClass() != URLStorage.class)
        {
          return false;
        }
        else
        {
          URLStorage other = (URLStorage)that;
          return uri == null ? other.uri == null : uri.equals(other.uri);
        }
      }

      @Override
      public String toString()
      {
        return String.valueOf(uri);
      }
    }
  }

  static class JavaEditorInput extends FileEditorInput
  {
    private boolean isConnected;

    private boolean isWorkingCopy;

    private ICompilationUnit workingCopy;

    public JavaEditorInput(IFile file, String content)
    {
      super(file);
      try
      {
        IPath path = file.getFullPath();
        FileBuffers.getTextFileBufferManager().connect(path, LocationKind.IFILE, new NullProgressMonitor());
        isConnected = true;
        ITextFileBuffer textFileBuffer = FileBuffers.getTextFileBufferManager().getTextFileBuffer(path, LocationKind.IFILE);
        if (textFileBuffer instanceof IStateValidationSupport)
        {
          ((IStateValidationSupport)textFileBuffer).validationStateChanged(true, Status.OK_STATUS);
        }
        IDocument document = textFileBuffer.getDocument();
        document.set(content);
      }
      catch (CoreException exception)
      {
        CodeGenUIPlugin.getPlugin().log(exception);
      }
    }

    public synchronized ITypeRoot getWorkingCopy(ITypeRoot inputJavaElement)
    {
      if (!isWorkingCopy && inputJavaElement instanceof ICompilationUnit)
      {
        try
        {
          ICompilationUnit workingCopy = (ICompilationUnit)inputJavaElement;
          workingCopy.becomeWorkingCopy(new NullProgressMonitor());
          this.workingCopy = workingCopy;
          isWorkingCopy = true;
        }
        catch (JavaModelException exception)
        {
          isWorkingCopy = true;
          CodeGenUIPlugin.getPlugin().log(exception);
        }
      }

      return inputJavaElement;
    }

    public void releaseWorkingCopy()
    {
      if (workingCopy != null)
      {
        try
        {
          workingCopy.discardWorkingCopy();
        }
        catch (JavaModelException exception)
        {
          CodeGenUIPlugin.getPlugin().log(exception);
        }
      }
    }

    public void release()
    {
      if (isConnected)
      {
        IPath path = getFile().getFullPath();
        try
        {
          FileBuffers.getTextFileBufferManager().disconnect(path, LocationKind.IFILE, new NullProgressMonitor());
        }
        catch (CoreException exception)
        {
          CodeGenUIPlugin.getPlugin().log(exception);
        }
      }
    }
  }

  @SuppressWarnings("restriction")
  static final class JavaEditor extends org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor
  {
    static final Map<String, String> SELECTION_ACTIONS = new LinkedHashMap<String, String>();

    static
    {
      SELECTION_ACTIONS.put(org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction.ENCLOSING, IJavaEditorActionDefinitionIds.SELECT_ENCLOSING);
      SELECTION_ACTIONS.put(org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction.NEXT, IJavaEditorActionDefinitionIds.SELECT_NEXT);
      SELECTION_ACTIONS.put(org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction.PREVIOUS, IJavaEditorActionDefinitionIds.SELECT_PREVIOUS);
      SELECTION_ACTIONS.put(org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction.HISTORY, IJavaEditorActionDefinitionIds.SELECT_LAST);
    }

    private final JETEditor jetEditor;

    private boolean navigating;

    private IAction openDeclarationAction;

    private DefaultCharacterPairMatcher bracketMatcher;

    public JavaEditor(JETEditor jetEditor)
    {
      this.jetEditor = jetEditor;
      setDocumentProvider(new StatusFilteringForwardingDocumentProvider(getDocumentProvider()));
    }

    SourceViewer getJavaSourceViewer()
    {
      return (SourceViewer)getSourceViewer();
    }

    @Override
    public IAction getAction(String actionID)
    {
      if ("OpenEditor".equals(actionID))
      {
        return getOpenDeclarationAction();
      }

      final IAction action = super.getAction(actionID);
      String actionDefinitionID = SELECTION_ACTIONS.get(actionID);
      if (actionDefinitionID != null)
      {
        return new Action(action.getText(), action.getStyle())
          {
            @Override
            public void run()
            {
              try
              {
                navigating = true;
                action.run();
                jetEditor.selectionSynchronizer.sync(getJavaSourceViewer());
              }
              finally
              {
                navigating = false;
              }
            }
          };
      }
      else if (EXTRACT_LOCAL_VARIABLE_ACTION_ID.equals(actionID))
      {
        return new JETExtractLocalVariableAction(jetEditor, action);
      }
      else
      {
        return action;
      }
    }

    IJavaElement[] getSelectedElements()
    {
      ITypeRoot inputJavaElement = getInputJavaElement();
      Point selectedRange = getJavaSourceViewer().getSelectedRange();
      try
      {
        return inputJavaElement.codeSelect(selectedRange.x, selectedRange.y);
      }
      catch (JavaModelException e)
      {
        return null;
      }
    }

    DefaultCharacterPairMatcher getJavaBracketMatcher()
    {
      if (bracketMatcher == null)
      {
        try
        {
          Field field = org.eclipse.jdt.internal.ui.javaeditor.JavaEditor.class.getDeclaredField("fBracketMatcher");
          field.setAccessible(true);
          bracketMatcher = (DefaultCharacterPairMatcher)field.get(this);
        }
        catch (Exception exception)
        {
        }
      }

      return bracketMatcher;
    }

    IHyperlinkDetector[] getHyperlinkDetectors()
    {
      IHyperlinkDetector[] hyperlinkDetectors = getSourceViewerConfiguration().getHyperlinkDetectors(getSourceViewer());
      return hyperlinkDetectors;
    }

    boolean isNavigating()
    {
      return navigating;
    }

    IAction getOpenDeclarationAction()
    {
      if (openDeclarationAction == null)
      {
        openDeclarationAction = new OpenAction(this)
          {
            @Override
            public void run(Object[] elements)
            {
              IFileEditorInput editorInput = (IFileEditorInput)getEditorInput();
              IPath editorInputPath = editorInput.getFile().getFullPath();
              for (Object element : elements)
              {
                if (element instanceof IJavaElement)
                {
                  IPath path = ((IJavaElement)element).getPath();
                  if (editorInputPath.equals(path))
                  {
                    try
                    {
                      navigating = true;
                      JavaUI.revealInEditor(JavaEditor.this, (IJavaElement)element);

                      ISourceViewer javaSourceViewer = JavaEditor.this.getJavaSourceViewer();
                      javaSourceViewer.getTextWidget().notifyListeners(SWT.Selection, new Event());
                    }
                    finally
                    {
                      navigating = false;
                    }
                    return;
                  }
                }
              }

              super.run(elements);
            }
          };
      }
      return openDeclarationAction;
    }

    IAction getGotoMatchingBracketAction()
    {
      final IAction gotoMatchingBracketAction = getAction(org.eclipse.jdt.internal.ui.javaeditor.GotoMatchingBracketAction.GOTO_MATCHING_BRACKET);
      gotoMatchingBracketAction.setActionDefinitionId(IJavaEditorActionDefinitionIds.GOTO_MATCHING_BRACKET);
      return new Action(gotoMatchingBracketAction.getText(), gotoMatchingBracketAction.getStyle())
        {
          @Override
          public void run()
          {
            JETBracketMatcher jetBracketMatcher = jetEditor.getJetBracketMatcher();
            ISourceViewer jetSourceViewer = jetEditor.getSourceViewer();
            Point selectedRange = jetSourceViewer.getSelectedRange();
            IRegion jetMatch = jetBracketMatcher.match(jetSourceViewer.getDocument(), selectedRange.x);
            if (jetMatch == null)
            {
              try
              {
                navigating = true;
                gotoMatchingBracketAction.run();
              }
              finally
              {
                navigating = false;
              }
            }
            else
            {
              int offset = jetMatch.getOffset();
              int length = jetMatch.getLength();
              int targetOffset = (ICharacterPairMatcher.RIGHT == jetBracketMatcher.getAnchor()) ? offset + 1 : offset + length;
              jetEditor.selectAndReveal(targetOffset, 0);
            }
          }
        };
    }

    IContentAssistant getContentAssist()
    {
      try
      {
        Field field = SourceViewer.class.getDeclaredField("fContentAssistant");
        field.setAccessible(true);
        return (IContentAssistant)field.get(getSourceViewer());
      }
      catch (Exception exception)
      {
        throw new RuntimeException(exception);
      }
    }

    IQuickAssistAssistant getQuickAssistAssistant()
    {
      try
      {
        Field field = SourceViewer.class.getDeclaredField("fQuickAssistAssistant");
        field.setAccessible(true);
        return (IQuickAssistAssistant)field.get(getSourceViewer());
      }
      catch (Exception exception)
      {
        throw new RuntimeException(exception);
      }
    }

    IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks)
    {
      JETCompilationUnit compilerResult = jetEditor.getCompilationUnit();
      if (compilerResult != null)
      {
        IRegion javaWordRegion = org.eclipse.jdt.internal.ui.text.JavaWordFinder.findWord(textViewer.getDocument(), region.getOffset());
        final int correspondingTemplateFileID = compilerResult.getCorrespondingTemplateFileID(region.getOffset());
        if (correspondingTemplateFileID != -1 && correspondingTemplateFileID != jetEditor.getFileID())
        {
          JETHyperLink jetHyperLink = new JETHyperLink(
            jetEditor,
            javaWordRegion == null || javaWordRegion.getLength() == 0 ? new Region(region.getOffset(), 1) : javaWordRegion,
            correspondingTemplateFileID,
            toURI(jetEditor.getDocumentManager().getEditorInput(correspondingTemplateFileID)).toString())
            {
              @Override
              public String getTypeLabel()
              {
                return "Open JET";
              }
            };
          return new IHyperlink []{ jetHyperLink };
        }
      }
      return null;
    }

    @Override
    protected void markInNavigationHistory()
    {
      // Don't maintain history for the Java file itself.
    }

    @Override
    protected ITypeRoot getInputJavaElement()
    {
      ITypeRoot inputJavaElement = super.getInputJavaElement();
      IEditorInput editorInput = getEditorInput();
      if (editorInput instanceof JavaEditorInput)
      {
        return ((JavaEditorInput)editorInput).getWorkingCopy(inputJavaElement);
      }
      else
      {
        return inputJavaElement;
      }
    }

    @Override
    public void dispose()
    {
      super.dispose();

      IEditorInput editorInput = getEditorInput();
      if (editorInput instanceof JavaEditorInput)
      {
        ((JavaEditorInput)editorInput).releaseWorkingCopy();
      }
    }

    void setInput(IFile javaFile, String compilationUnit)
    {
      IFile effectiveJavaFile = javaFile;
      boolean javaFileExists = javaFile.exists();
      if (!javaFileExists)
      {
        // Ensure that the file is contained by an actual existing project or folder.
        IContainer parent = javaFile.getParent();
        while (!parent.exists())
        {
          parent = parent.getParent();
        }

        if (parent.getType() == IResource.ROOT)
        {
          parent = jetEditor.getEditorInputFile().getParent();
        }

        effectiveJavaFile = parent.getFile(new Path(javaFile.getName()));
      }

      IEditorInput newInput = javaFileExists ? new FileEditorInput(effectiveJavaFile) : new JavaEditorInput(effectiveJavaFile, compilationUnit);
      IEditorInput oldInput = getEditorInput();
      if (!newInput.equals(oldInput))
      {
        setInput(newInput);
        getJavaSourceViewer().setEditable(false);
        if (oldInput instanceof JavaEditorInput)
        {
          ((JavaEditorInput)oldInput).releaseWorkingCopy();
        }
      }

      jetEditor.getJavaPosition().addToDocument(getJavaSourceViewer().getDocument());

      if (newInput instanceof JavaEditorInput)
      {
        ((JavaEditorInput)newInput).release();
      }
    }

    @Override
    public void init(IEditorSite site, IEditorInput input) throws PartInitException
    {
      super.init(new DelegatingEditorSite(site), input);

      IPerspectiveDescriptor perspective = getSite().getPage().getPerspective();
      String id = EDITOR_SHOW_BREADCRUMB + "." + perspective.getId(); //$NON-NLS-1$
      IPreferenceStore preferenceStore = getPreferenceStore();
      PreferenceStore localPreferenceStore = new PreferenceStore();
      localPreferenceStore.setValue(PreferenceConstants.EDITOR_FOLDING_ENABLED, false);
      setPreferenceStore(new ChainedPreferenceStore(new IPreferenceStore []{ localPreferenceStore, preferenceStore }));
      localPreferenceStore.setValue(id, true);
    }

    @Override
    public void createPartControl(Composite parent)
    {
      super.createPartControl(parent);

      new VisibleCaretHandler(getSourceViewer().getTextWidget(), jetEditor.getSourceViewer().getTextWidget());

      // The Java editor does semantic highlighting on a background thread that updates the Java viewer at some arbitrary point in time later.
      ((ITextViewerExtension4)getSourceViewer()).addTextPresentationListener(new ITextPresentationListener()
        {
          private Color getBackground(JETJavaRange jetRange)
          {
            JETItem jetItem = jetRange.getJETItem();
            if (jetItem instanceof JETScriptletItem)
            {
              return ColorManager.INSTANCE.getBackground(JETScriptletRule.TOKEN.getType());
            }
            else if (jetItem instanceof JETExpressionItem)
            {
              return ColorManager.INSTANCE.getBackground(JETExpressionRule.TOKEN.getType());
            }
            else if (jetItem instanceof JETLiteralItem)
            {
              return ColorManager.INSTANCE.getBackground(JETContentRule.TOKEN.getType());
            }
            else if (jetItem instanceof JETSubItem && jetItem.getParent() instanceof JETCommentItem)
            {
              return ColorManager.INSTANCE.getBackground(JETCommentRule.TOKEN.getType());
            }
            else
            {
              return ColorManager.INSTANCE.getBackground(JETDirectiveRule.TOKEN.getType());
            }
          }

          public void applyTextPresentation(TextPresentation textPresentation)
          {
            // Start two parallel iterators on the JET ranges and the style ranges.
            List<JETJavaRange> ranges = jetEditor.getRanges();
            if (!ranges.isEmpty())
            {
              Iterator<StyleRange> i = textPresentation.getAllStyleRangeIterator();
              if (i.hasNext())
              {
                // Accumulate altered style ranges.
                List<StyleRange> newStyleRanges = new ArrayList<StyleRange>();

                // Initialize the current starting point for each scanned JET range and style range.
                Iterator<JETJavaRange> r = ranges.iterator();
                JETJavaRange range = r.next();
                StyleRange styleRange = i.next();

                LOOP: while (true)
                {
                  // Skip any empty ranges, e.g., the ones from an empty scriptlet.
                  int rangeJavaLength = range.getJavaLength();
                  while (rangeJavaLength == 0)
                  {
                    if (!r.hasNext())
                    {
                      newStyleRanges.add(styleRange);
                      break LOOP;
                    }

                    range = r.next();
                    rangeJavaLength = range.getJavaLength();
                  }

                  int javaOffset = styleRange.start;
                  int rangeJavaOffset = range.getJavaOffset();

                  // Consume ranges until we hit one that overlaps with the current style range.
                  while (rangeJavaOffset + rangeJavaLength <= javaOffset)
                  {
                    if (!r.hasNext())
                    {
                      newStyleRanges.add(styleRange);
                      break LOOP;
                    }

                    range = r.next();
                    rangeJavaOffset = range.getJavaOffset();
                    rangeJavaLength = range.getJavaLength();
                  }

                  // Consume style ranges until we hit one that overlaps with the current range.
                  while (javaOffset + styleRange.length <= rangeJavaOffset)
                  {
                    newStyleRanges.add(styleRange);
                    if (i.hasNext())
                    {
                      styleRange = i.next();
                      javaOffset = styleRange.start;
                    }
                    else
                    {
                      break LOOP;
                    }
                  }

                  // Trim off any unstyled prefix from the style range.
                  int delta = rangeJavaOffset - javaOffset;
                  if (delta > 0)
                  {
                    // The prefix has normal style so we clone the range and reduce the length.
                    StyleRange newStyleRange = (StyleRange)styleRange.clone();
                    newStyleRange.length = delta;
                    newStyleRanges.add(newStyleRange);

                    // If we've consumed the whole style range...
                    if (styleRange.length == delta)
                    {
                      if (i.hasNext())
                      {
                        // If there are style ranges left, continue the loop.
                        styleRange = i.next();
                        continue;
                      }
                      else
                      {
                        // Otherwise we're done.
                        break;
                      }
                    }

                    // Advance the style range.
                    javaOffset = styleRange.start += delta;
                    styleRange.length -= delta;
                  }

                  // Consume the styled part of the style range.
                  int lengthDelta = styleRange.length - rangeJavaLength;
                  if (lengthDelta > 0)
                  {
                    // The new style range completely consumes the range.
                    StyleRange newStyleRange = (StyleRange)styleRange.clone();
                    newStyleRange.length = rangeJavaLength;
                    newStyleRange.background = getBackground(range);
                    newStyleRanges.add(newStyleRange);

                    // Advance the style range by the consumed length.
                    styleRange.start += rangeJavaLength;
                    styleRange.length = lengthDelta;

                    // Advance the range if there are any left.
                    if (!r.hasNext())
                    {
                      // If not, consume the remaining portion of the style range and terminate.
                      newStyleRanges.add(styleRange);
                      break LOOP;
                    }
                    else
                    {
                      range = r.next();
                    }
                  }
                  else
                  {
                    // The style range is completely consumed by the range.
                    styleRange.background = getBackground(range);
                    newStyleRanges.add(styleRange);

                    // If we're out of style ranges, terminate.
                    if (!i.hasNext())
                    {
                      break;
                    }
                    else
                    {
                      // Otherwise, advance the range to the remaining portion and advanced to the next style range.
                      range = range.subrange(styleRange.length);
                      styleRange = i.next();
                    }
                  }
                }

                // Consume any remaining unaltered style ranges.
                while (i.hasNext())
                {
                  newStyleRanges.add(i.next());
                }

                textPresentation.clear();
                for (StyleRange newStyleRange : newStyleRanges)
                {
                  textPresentation.addStyleRange(newStyleRange);
                }
              }
            }

            if (jetEditor.isJavaEditorInSync())
            {
              jetEditor.invalidateVisibleTextPresentation(true);
            }
          }
        });

      try
      {
        // Disable the Java editor from also setting the last edit location.
        Field textListenerField = AbstractTextEditor.class.getDeclaredField("fTextListener");
        textListenerField.setAccessible(true);
        Object textListener = textListenerField.get(this);
        Field runnableField = textListener.getClass().getDeclaredField("fRunnable");
        runnableField.setAccessible(true);
        runnableField.set(textListener, new Runnable()
          {
            public void run()
            {
            }
          });
      }
      catch (Exception exception)
      {
        // If that doesn't work, it's not tragic, just annoying.
      }

      ((IPostSelectionProvider)getSelectionProvider()).addSelectionChangedListener(new JavadocUpdater(jetEditor));
    }

    private static final class JavadocUpdater implements ISelectionChangedListener
    {
      private final JETEditor jetEditor;

      public JavadocUpdater(JETEditor jetEditor)
      {
        this.jetEditor = jetEditor;
      }

      public void selectionChanged(SelectionChangedEvent event)
      {
        JavaEditor javaEditor = jetEditor.getJavaEditor();
        ISelectionProvider selectionProvider = javaEditor.getSelectionProvider();
        ISelectionValidator selectionValidator = (ISelectionValidator)selectionProvider;
        if (selectionValidator.isValid(event.getSelection()))
        {
          IWorkbenchPage page = jetEditor.getSite().getPage();
          IViewPart javadocView = page.findView(JavaUI.ID_JAVADOC_VIEW);
          if (javadocView != null)
          {
            IViewPart[] viewStack = page.getViewStack(javadocView);
            if (viewStack != null && viewStack.length > 0 && viewStack[0] == javadocView)
            {
              ((ISelectionListener)javadocView).selectionChanged(javaEditor, selectionProvider.getSelection());
            }
          }
        }
      }
    }

    private static final class StatusFilteringForwardingDocumentProvider extends ForwardingDocumentProvider
    {
      public StatusFilteringForwardingDocumentProvider(IDocumentProvider parentProvider)
      {
        super(IJavaPartitions.JAVA_PARTITIONING, new IDocumentSetupParticipant()
          {
            public void setup(IDocument document)
            {
            }
          }, parentProvider);
      }

      @Override
      public IStatus getStatus(Object element)
      {
        return Status.OK_STATUS;
      }
    }

    private static class DelegatingEditorSite implements IEditorSite
    {
      private final IEditorSite editorSite;

      private SubActionBars subActionBars;

      public DelegatingEditorSite(IEditorSite editorSite)
      {
        this.editorSite = editorSite;
        subActionBars = new SubActionBars(getEditorSite().getActionBars());
      }

      public IEditorSite getEditorSite()
      {
        return editorSite;
      }

      public IEditorActionBarContributor getActionBarContributor()
      {
        return getEditorSite().getActionBarContributor();
      }

      public String getId()
      {
        return JavaUI.ID_CU_EDITOR;
      }

      @SuppressWarnings("rawtypes")
      public boolean hasService(Class api)
      {
        return false;
      }

      @SuppressWarnings({ "unchecked", "rawtypes" })
      public Object getService(Class api)
      {
        return null;
      }

      public String getPluginId()
      {
        return getEditorSite().getPluginId();
      }

      @SuppressWarnings({ "unchecked", "rawtypes" })
      public Object getAdapter(Class adapter)
      {
        return getEditorSite().getAdapter(adapter);
      }

      public IWorkbenchPage getPage()
      {
        return getEditorSite().getPage();
      }

      public ISelectionProvider getSelectionProvider()
      {
        return getEditorSite().getSelectionProvider();
      }

      public Shell getShell()
      {
        return getEditorSite().getShell();
      }

      public IActionBars getActionBars()
      {
        return subActionBars;
      }

      public IWorkbenchPart getPart()
      {
        return getEditorSite().getPart();
      }

      public IWorkbenchWindow getWorkbenchWindow()
      {
        return getEditorSite().getWorkbenchWindow();
      }

      public void setSelectionProvider(ISelectionProvider provider)
      {
        getEditorSite().setSelectionProvider(provider);
      }

      public String getRegisteredName()
      {
        return getEditorSite().getRegisteredName();
      }

      public void registerContextMenu(String menuId, MenuManager menuManager, ISelectionProvider selectionProvider)
      {
      }

      public void registerContextMenu(MenuManager menuManager, ISelectionProvider selectionProvider, boolean includeEditorInput)
      {
      }

      public void registerContextMenu(MenuManager menuManager, ISelectionProvider selectionProvider)
      {
      }

      public void registerContextMenu(String menuId, MenuManager menuManager, ISelectionProvider selectionProvider, boolean includeEditorInput)
      {
      }

      @SuppressWarnings("deprecation")
      public org.eclipse.ui.IKeyBindingService getKeyBindingService()
      {
        return new DelegatingKeyBindingService();
      }

      @SuppressWarnings("deprecation")
      private static class DelegatingKeyBindingService implements org.eclipse.ui.IKeyBindingService
      {
        public String[] getScopes()
        {
          return new String [0];
        }

        public void registerAction(IAction action)
        {
        }

        public void setScopes(String[] scopes)
        {
        }

        public void unregisterAction(IAction action)
        {
        }
      }
    }
  }

  static abstract class SneakyRunnable implements Runnable
  {
    @SuppressWarnings("unchecked")
    private static <E extends Throwable> void sneakyThrow(Throwable throwable) throws E
    {
      throw (E)throwable;
    }

    public final void run()
    {
      try
      {
        execute();
      }
      catch (Throwable throwable)
      {
        SneakyRunnable.<RuntimeException> sneakyThrow(throwable);
      }
    }

    protected abstract void execute() throws Throwable;
  }

  static IEditorPart open(IEditorSite site, String locationURI)
  {
    IFile file = toFile(URI.createURI(locationURI));
    if (file != null && file.exists())
    {
      try
      {
        String editorID = site.getWorkbenchWindow().getWorkbench().getEditorRegistry().getDefaultEditor(file.getName()).getId();
        return site.getPage().openEditor(new FileEditorInput(file), editorID);
      }
      catch (PartInitException exception)
      {
        CodeGenUIPlugin.write(exception);
      }
    }

    return null;
  }

  static IFile toFile(URI uri)
  {
    return uri.isPlatformResource() ? ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(uri.toPlatformString(true))) : null;
  }

  static URI toPlatformResourceURI(IEditorInput input)
  {
    return toURI(toFile(input));
  }

  static IFile toFile(IEditorInput input)
  {
    if (input instanceof StorageEditorInput)
    {
      return ((StorageEditorInput)input).getFile();
    }
    else
    {
      return input instanceof IAdaptable ? (IFile)((IAdaptable)input).getAdapter(IFile.class) : null;
    }
  }

  static URI toURI(IResource resource)
  {
    return resource == null ? null : URI.createPlatformResourceURI(resource.getFullPath().toString(), true);
  }

  static IRegion toRegion(JETItem jetItem)
  {
    int start = jetItem.getStartOffset();
    int stop = jetItem.getStopOffset();
    return new Region(start, stop - start);
  }

  static IEditorInput toEditorInput(URI uri)
  {
    if (uri != null && uri.isPlatformResource())
    {
      IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(uri.toPlatformString(true)));
      if (file.isAccessible())
      {
        return new FileEditorInput(file);
      }
    }

    return new StorageEditorInput(JETNature.resolve(uri));
  }

  static IFile toFile(IPath path)
  {
    return ResourcesPlugin.getWorkspace().getRoot().getFile(path);
  }

  static URI toURI(IEditorInput input)
  {
    if (input instanceof IFileEditorInput)
    {
      return toURI(((IFileEditorInput)input).getFile());
    }
    else if (input instanceof StorageEditorInput)
    {
      return URI.createURI(((StorageEditorInput)input).getURI().toString());
    }
    else if (input instanceof IURIEditorInput)
    {
      return URI.createURI(((IURIEditorInput)input).getURI().toString());
    }
    else
    {
      return null;
    }
  }

  static boolean installOnDocument(IDocument document, Position position, String category, IPositionUpdater positionUpdater)
  {
    if (document != null && position != null)
    {
      if (!document.containsPositionCategory(category))
      {
        document.addPositionCategory(category);
        document.addPositionUpdater(positionUpdater);
      }

      try
      {
        document.addPosition(category, position);
        return true;
      }
      catch (Exception excetpion)
      {
      }
    }

    return false;
  }

  static boolean uninstallFromDocument(IDocument document, Position position, String category, IPositionUpdater positionUpdater)
  {
    if (document != null && position != null)
    {
      try
      {
        document.removePosition(category, position);

        Position[] positions = document.getPositions(category);
        if (positions == null || positions.length == 0)
        {
          document.removePositionCategory(category);
          document.removePositionUpdater(positionUpdater);
        }

        return true;
      }
      catch (BadPositionCategoryException exception)
      {
      }
    }

    return false;
  }
}