* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*   http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*/

* The DOM structure for an editor is as follows:

*

* <pre>

* &lt;div class=&quot;editor&quot; contentEditable=&quot;...&quot;&gt; unselectable=&quot;on&quot;

*   &lt;div contentEditable=&quot;...&quot;&gt; unselectable=&quot;on&quot;&gt;

*     (this is the 'pre' decorator element, and the editor doesn't care what goes in here)

*   &lt;/div&gt;

*   &lt;div&gt;(editable content)&lt;/div&gt;

* &lt;/div&gt;

* </pre>

*

* The decorator is required for adding inline decorations on IE7 (because a contentEditable

* region must be rectangular, so decorations must be included in that region).

* The editor contains logic to ensure that, even though the editable region includes a

* decorator, editing actions (including making selections) are restricted to the document.

*

* @author danilatos@google.com (Daniel Danilatos)

*/

// <div class="editor" contentEditable="..." unselectable="on">

//   <div contentEditable="false" unselectable="on">

//     (this is the decorator element, and the editor doesn't care what goes in here)

//   </div>

//   <div>(editable content)</div>

// </div>

//

    Editor, LogicalPanel, HtmlSelectionHelper, JavaScriptEventListener {

  /** CSS class applied to editor document's top level html element when in edit mode */

  public static final String WAVE_EDITOR_EDIT_ON = "wave-editor-on";

  /** CSS class applied to editor document's top level html element when not in edit mode */

  public static final String WAVE_EDITOR_EDIT_OFF = "wave-editor-off";

   * Minimal set of dependencies on the editor for ContentDocument

   * (mostly the fault of various doodads).

   */

  public interface MiniBundle {

    /***/

    TypingExtractor getTypingExtractor();

    /***/

    boolean inEditMode();

    /** Spell suggestions */

    SuggestionsManager getSuggestionsManager();

    /***/

    PassiveSelectionHelper getPassiveSelectionHelper();

    /** ContentDocument updates this registry of "elements with display modes" :( */

    CopyOnWriteSet<ContentElement> getElementsWithDisplayModes();

    RepairListener getRepairListener();

    EditorContext getEditorContext();

    /**

     * Brings the editor into a consistent state, possibly asynchronously.

     *

     * "Consistent" means that the editor's document state includes the effects of

     * all browser-events before now, and that that state is consistent with the

     * operations that this editor has pushed out to the outgoing operation stream

     * (i.e., no operations are buffered).

     *

     * This should be called immediately prior to applying operations to the

     * document, i.e.

     * {@link ContentDocument#consume(org.waveprotocol.wave.model.document.operation.DocOp)}

     *

     * NOTE(danilatos): While this method is re-entrant, if it returns false,

     * there is not much point calling it again until the continuation command has

     * been executed.

     *

     * @param resume if the editor's document is not in a consistent state, a

     *        callback to fire as soon as consistency is reached.

     * @return true if the editor's document is in a consistent state, false

     *         otherwise (note: {@code resume} is not called if this method

     *         returns true).

     */

    boolean flush(Runnable resume);

    /**

     * Notifies the editor that an external source (i.e. incoming op) has applied

     * a DocOp to the document.

     *

     * @param op

     */

    void onIncomingOp(DocOp op);

  }

  @VisibleForTesting final MiniBundle editorPackage = new MiniBundle() {

    /** {@inheritDoc} */

    public TypingExtractor getTypingExtractor() {

      return typing;

    }

    /** {@inheritDoc} */

    public boolean inEditMode() {

      return EditorImpl.this.isEditing();

    }

    /** {@inheritDoc} */

    public SuggestionsManager getSuggestionsManager() {

      return suggestionsManager;

    }

    /** {@inheritDoc} */

    public PassiveSelectionHelper getPassiveSelectionHelper() {

      return passiveSelectionHelper;

    }

    @Override

    public CopyOnWriteSet<ContentElement> getElementsWithDisplayModes() {

      return elementsWithDisplayEditModes;

    }

    @Override

    public RepairListener getRepairListener() {

      return repairListener;

    }

    @Override

    public EditorContext getEditorContext() {

      return EditorImpl.this;

    }

    @Override

    public boolean flush(Runnable resume) {

      return EditorImpl.this.flush(resume);

    }

    @Override

    public void onIncomingOp(DocOp op) {

      EditorImpl.this.onIncomingOp(op);

    }

  };

  /**

   * Resources used in the Editor.

   */

  public interface Resources extends ClientBundle {

    /** Css resource */

    // TODO(danilatos): extends CssResource to get obfuscated class name

    // TODO(danilatos): factor our CSS into per-widget bundles (e.g., image thumbnail, paragraph)

    @Source("Editor.css")

    @NotStrict  // TODO(danilatos): make Strict by including all classes in the CssResource

    CssResource css();

  }

  /**

   * Singleton instance of resource bundle

   */

  private static final CssResource css = GWT.<Resources>create(Resources.class).css();

  /**

   * Attribute used to mark the editable document element.

   */

  static final String EDITABLE_DOC_MARKER = "editableDocMarker";

  /**

   * Shorthand for the main div of the editor

   */

  private final Element div;

  /**

   * List of ContentElements that needs to be notified when we change mode

   */

  private final CopyOnWriteSet<ContentElement> elementsWithDisplayEditModes

      = CopyOnWriteSet.create();

  /**

   * Node manager

   */

  private NodeManager nodeManager;

  private CaretMovementHelper caretMoveHelper;

  private HtmlSelectionHelper htmlSelectionHelper;

  /**

   * Always use this unless you know what you are doing

   */

  private PassiveSelectionHelper passiveSelectionHelper;

  /**

   * Use this to possibly correct problems in the document (side effect of

   * generating operations) whilst getting the selection. If in doubt,

   * use the passive selection helper.

   */

  private AggressiveSelectionHelper aggressiveSelectionHelper;

  /**

   * Editor's content document, including doc div

   */

  protected ContentDocument content;

  /**

   * Configuration

   */

  private EditorSettings settings = EditorSettings.DEFAULT;

  private SilentOperationSink<? super DocOp> innerOutputSink;

  /**

   * Permits sending out operations, and receiving local operations.

   * Currently useful for debugging purposes only.

   */

  private boolean permitOperations = true;

  /** Buffer of outgoing ops, for when we suppress sending them. */

  List<DocOp> suppressedOutgoingOps;

  /**

   * Sink for outgoing operations

   *

   * TODO(mtsui/danilatos): Move this out of the editor as well.

   */

  private final SilentOperationSink<DocOp> outgoingOperationSink =

      new SilentOperationSink<DocOp>() {

        public void consume(DocOp op) {

          try {

            if (permitOperations) {

              innerOutputSink.consume(op);

            } else {

              suppressedOutgoingOps.add(op);

            }

            if (responsibility.withinDirectSequence()) {

              editorUndoManager.undoableOp(op);

            } else {

              editorUndoManager.nonUndoableOp(op);

            }

            // And schedule notification update

            // NOTE(danilatos): We might want the coord updated parameter to be true,

            // but see the discussion in #execute(op) for details...

            scheduleUpdateNotification(false, false, true, responsibility.withinDirectSequence());

          } catch (Exception e) {

            if (innerOutputSink == null) {

              EditorStaticDeps.logger.fatal().logPlainText("Output sink is null",

                  new ClientDebugException("", e));

            } else {

              EditorStaticDeps.logger.fatal().logPlainText("Output sink threw exception", e);

            }

          }

        }

      };

  /**

   * A command-queue for commands that need to run when the editor is in a

   * consistent state.  The addition of commands to this queue triggers a

   * deferred command to poll the consistency state and executing queued

   * commands until the queue is empty.

   */

  private class ConsistentStateCommandRunner implements Scheduler.Task {

    /** Queued commands, FIFO. */

    private Queue<Runnable> commands = CollectionUtils.createQueue();

    private ConsistentStateCommandRunner() {

    }

    public void schedule(Runnable c) {

      commands.add(c);

      if (permitOperations) { // Prevent constant rescheduling

        ScheduleCommand.addCommand(this);

      }

    }

    @Override

    public void execute() {

      Queue<Runnable> backup = commands;

      commands = CollectionUtils.createQueue();

      while (isConsistent() && !backup.isEmpty()) {

        backup.poll().run();

      }

      // Move any unexecuted commands back into the main queue, preserving any

      // commands that were scheduled during the above execution.

      backup.addAll(commands);

      // Restore the copy

      commands = backup;

      if (!commands.isEmpty()) {

        if (permitOperations) { // Prevent constant rescheduling

          ScheduleCommand.addCommand(this);

        }

      }

    }

  }

  /**

   * Deferred command for checking if we can resume incoming operations

   */

  private final ConsistentStateCommandRunner consistencyQueue = new ConsistentStateCommandRunner();

  /**

   * Handler for the results of typing

   */

  TypingSink typingSink = new TypingSink() {

    @Override

    public void aboutToFlush() {

      domMutationReverter.flush();

      // Some errors here aren't fatal, we can probably just ignore them, but

      // let's log them because they were unexpected, and might imply other problems...

      if (webkitEndOfLinkHackTextNode != null) {

        EditorStaticDeps.startIgnoreMutations();

        try {

          Point<Node> caret = getHtmlSelection().getFocus();

          if (caret.isInTextNode()) {

            Text hackedTextNode = caret.getContainer().cast();

            Node link = hackedTextNode.getPreviousSibling();

            while (link != null && DomHelper.isTextNode(link)) {

              link = link.getPreviousSibling();

            }

            if (link == null) {

              EditorStaticDeps.logger.error().log("No link before the link hack?");

              return;

            }

            Element anchor = link.cast();

            if (!anchor.getTagName().equalsIgnoreCase("a")) {

              EditorStaticDeps.logger.error().log(

                  "Some other element before the link hack? (" + anchor.getTagName() + ")");

              // Don't return, we still want to move the text nodes...

            }

            Node nodeAfter;

            if (caret.getTextOffset() == hackedTextNode.getLength()) {

              nodeAfter = hackedTextNode.getNextSibling();

            } else {

              nodeAfter = hackedTextNode.splitText(caret.getTextOffset());

            }

            DomHelper.moveNodes(anchor, anchor.getNextSibling(), nodeAfter, null);

            NativeSelectionUtil.setCaret(Point.<Node>inText(hackedTextNode, hackedTextNode.getLength()));

            // TODO: Set the annotation caret to turn the link off.

          } else {

            EditorStaticDeps.logger.error().log("End of link hack caret not in text node!?");

          }

        } finally {

          webkitEndOfLinkHackTextNode = null;

          EditorStaticDeps.endIgnoreMutations();

        }

      }

    }

    @Override

    public void typingReplace(Point<ContentNode> start, int deletionSize, String text,

        RestrictedRange<ContentNode> range) {

      int location = mapper().getLocation(start);

      Nindo op = generateReplaceTextOp(location, deletionSize, text);

      try {

        applyRepairingOperation(op);

        typingFinished(range);

      } catch (LocalOperationException e) {

        EditorStaticDeps.logger.error().log(

            "Swallowing Error: Invalid operation sent to TypingSink (" + e + ")");

      }

      currentSelectionBias = BiasDirection.LEFT;

    }

    void typingFinished(RestrictedRange<ContentNode> range) {

      FocusedPointRange<Node> selection = getHtmlSelection();

      boolean selectionAffected =

          repairer.zipRange(range, selection == null ? null : selection.getFocus().getContainer());

      if (selectionAffected) {

        assert selection != null && selection.getFocus() != null;

        Node n = selection.getFocus().getContainer();

        // Find selection in fragmented text nodes. What if we can't find it?

        Node newTextNode = n;

        // NOTE(user): Ideally, the selection here should always be inside a

        // text node. However, since we are just calling getHtmlSelection here,

        // there is no obvious guarantee. In particular, when tracing

        // TypingExtractor.flush() it may be called inside a deferred command,

        // which means the selection can be anywhere.

        // TODO(user): Refactor this code to make it more explicit. Consider

        // passing in the selection rather than calling getHtmlSelection.

        if (LogLevel.showErrors() && !selection.getFocus().isInTextNode()) {

          EditorStaticDeps.logger.error().log(

              "selection while typing is expected to be in text node, but is not ",

              selection.getFocus());

        } else {

          int newTextOffset = selection.getFocus().getTextOffset();

          while (DomHelper.isTextNode(n) && n.<Text> cast().getLength() < newTextOffset) {

            newTextOffset -= n.<Text> cast().getLength();

            newTextNode = n.getNextSibling();

          }

          NativeSelectionUtil.setCaret(Point.inText(newTextNode, newTextOffset));

        }

      }

    }

    /**

     * Apply an operation only to the content wrapper dom. The usual use case is

     * that the html has been affected in a certain way already, and we are

     * matching that in the content with a series of operations. Hence we only

     * apply the operation to the wrapper dom.

     *

     * @param op

     */

    private void applyRepairingOperation(Nindo op) {

      responsibility.startDirectSequence();

      try {

        content.sourceNindoWithoutModifyingHtml(op);

      } finally {

        responsibility.endDirectSequence();

      }

    }

  };

  /**

   * A typing operation extractor for the editor

   */

  protected TypingExtractor typing;

  /**

   * IME composition extractor helper

   */

  private final ImeExtractor imeExtractor = new ImeExtractor();

  /**

   * Our paste extractor

   */

  private PasteExtractor pasteExtractor;

  /**

   * The thing that makes the content match the html or vice versa

   */

  private Repairer repairer;

  /**

   * Flag if editor is editing or displaying

   */

  protected boolean editing = false;

  /**

   * Keeps track of what styles are to be applied to the collapsed caret.

   */

  private CaretAnnotations caretStyles;

  /**

   * Keeps track of what the cursor's current bias is.

   */

  private BiasDirection currentSelectionBias = BiasDirection.LEFT;

  /**

   * My keyboard listeners

   */

  protected Set<KeySignalListener> keySignalListeners;

  /**

   * Registries for everything

   */

  protected Registries registries;

  /**

   * Our friendly equally friendly suggestion manager

   */

  protected SuggestionsManager suggestionsManager = null;

  private DomMutationReverter domMutationReverter;

  /** Stores all known key -> action bindings. */

  private KeyBindingRegistry keyBindings = KeyBindingRegistry.NONE;

  /**

   * Application specific editor event handler.

   */

  private final EditorEventsSubHandler eventsSubHandler = new EditorEventsSubHandlerImpl();

  /** Application specific annotation logic manager. */

  AnnotationBehaviourLogic<ContentNode> annotationLogic = null;

  private final EditorUpdateEventImpl updateEvent = new EditorUpdateEventImpl(this);

  /** stored scrollTops used by maybeSave/RestoreAncestorScrollPositions */

  private IdentityMap<Element, Integer> ancestorScrollTops;

  // TODO(user): This class can be broken down further. Things like paste/dom

  // mutation extraction are not really application specific and can be handled

  // in a separate class.

  private class EditorEventsSubHandlerImpl implements EditorEventsSubHandler {

    @Override

    public boolean handleBlockLevelCommands(EditorEvent event, ContentRange selection) {

      Point<ContentNode> start = selection.getFirst();

      Point<ContentNode> end = selection.getSecond();

      // Shonky key combos until toolbar

      if (KeyModifier.CTRL.check(event)) {

        int startLoc = mapper().getLocation(start);

        int endLoc = mapper().getLocation(end);

        int num = event.getKeyCode() - '1' + 1;

        if (num >= 1 && num <= 6) {

          if (num == 5) {

            final String listStyle;

            Line l = Paragraph.getFirstLine(mapper(), mapper().getLocation(start));

            if (Paragraph.LIST_TYPE.equals(l.getAttribute(Paragraph.SUBTYPE_ATTR)) &&

                !Paragraph.LIST_STYLE_DECIMAL.equals(l.getAttribute(Paragraph.LIST_STYLE_ATTR))) {

              listStyle = Paragraph.LIST_STYLE_DECIMAL;

            } else {

              listStyle = null; // default style

            }

            Paragraph.apply(mapper(), startLoc, endLoc, Paragraph.listStyle(listStyle), true);

          } else {

            final String type;

            if (num == 6) {

              type = null;

            } else {

              type = "h" + num;

            }

            Paragraph.toggle(mapper(), startLoc, endLoc, Paragraph.regularStyle(type));

          }

          settings.getInstrumentor().record(Action.SHORTCUT_HEADINGSTYLE);

          return true;

        } else if (num == 7) {

          Paragraph.apply(mapper(), startLoc, endLoc, Paragraph.Alignment.LEFT, true);

          Paragraph.apply(mapper(), startLoc, endLoc, Paragraph.Direction.LTR, true);

          settings.getInstrumentor().record(Action.SHORTCUT_ALIGNMENT);

          return true;

        } else if (num == 8) {

          Paragraph.apply(mapper(), startLoc, endLoc, Paragraph.Alignment.RIGHT, true);

          Paragraph.apply(mapper(), startLoc, endLoc, Paragraph.Direction.RTL, true);

          settings.getInstrumentor().record(Action.SHORTCUT_ALIGNMENT);

          return true;

        }

      } else if (event.getKeyCode() == KeyCodes.KEY_TAB) {

        handleTab(start, end, event.getShiftKey());

        return true;

      }

      return false;

    }

    @Override

    public boolean handleRangeKeyCombo(EditorEvent event, ContentRange selection) {

      assert !selection.isCollapsed();

      KeyCombo combo = EventWrapper.getKeyCombo(event.asEvent());

      // TODO(patcoleman): separate collapsed and normal, maybe also incorporate handled flag.

      if (keyBindings.hasAction(combo)) {

        keyBindings.getAction(combo).execute(EditorImpl.this);

        return true;

      }

      Point<ContentNode> start = selection.getFirst();

      Point<ContentNode> end = selection.getSecond();

      switch (combo) {

        // NOTE(user): Ideally, these should be changed to ORDER_B, ORDER_I,

        // ORDER_U. However, Safari on OSX does not emit any key events for

        // those combos, so we're allowing both on mac.

        // Also EventWrapper is broken at the moment, so registering ORDER_B

        // actually overrides CTRL_B

        case CTRL_B:

        case ORDER_B:

          doStyle(start, end, "fontWeight", "bold");

          settings.getInstrumentor().record(Action.SHORTCUT_BOLD);

          return true;

        case CTRL_I:

        case ORDER_I:

          doStyle(start, end, "fontStyle", "italic");

          settings.getInstrumentor().record(Action.SHORTCUT_ITALIC);

          return true;

        case CTRL_U:

        case ORDER_U:

          doStyle(start, end, "textDecoration", "underline");

          settings.getInstrumentor().record(Action.SHORTCUT_UNDERLINE);

          return true;

        case CTRL_SHIFT_5:

        case ORDER_SHIFT_5:

          doStyle(start, end, "textDecoration", "line-through");

          settings.getInstrumentor().record(Action.SHORTCUT_LINETHROUGH);

          return true;

      }

      return false;

    }

    @Override

    public boolean handleCollapsedKeyCombo(EditorEvent event, Point<ContentNode> caret) {

      // Handle events with carets

      // TODO(user): handle lots more events here

      KeyCombo combo = EventWrapper.getKeyCombo(event.asEvent());

      // TODO(patcoleman): separate collapsed and normal, maybe also incorporate handled flag.

      if (keyBindings.hasAction(combo)) {

        keyBindings.getAction(combo).execute(EditorImpl.this);

        return true;

      }

      switch (combo) {

        // NOTE(user): Ideally, these should be changed to ORDER_B, ORDER_I,

        // ORDER_U. However, Safari on OSX does not emit any key events for

        // those combos, so we're allowing both on mac.

        case CTRL_SPACE:

          // TODO(danilatos): Factor out configuration of popup key combo

          suggestionsManager.showSuggestionsNearestTo(caret);

          settings.getInstrumentor().record(Action.SHORTCUT_OPENNEARBYPOPUP);

          return true;

        case CTRL_B:

        case ORDER_B:

          doCollapsedStyle(caret, "fontWeight", "bold");

          settings.getInstrumentor().record(Action.SHORTCUT_BOLD);

          return true;

        case CTRL_I:

        case ORDER_I:

          doCollapsedStyle(caret, "fontStyle", "italic");

          settings.getInstrumentor().record(Action.SHORTCUT_ITALIC);

          return true;

        case CTRL_U:

        case ORDER_U:

          doCollapsedStyle(caret, "textDecoration", "underline");

          settings.getInstrumentor().record(Action.SHORTCUT_UNDERLINE);

          return true;

        case CTRL_SHIFT_5:

        case ORDER_SHIFT_5:

          doCollapsedStyle(caret, "textDecoration", "line-through");

          settings.getInstrumentor().record(Action.SHORTCUT_LINETHROUGH);

          return true;

      }

      return false;

    }

    @Override

    public void handleDomMutation(SignalEvent event) {

      domMutationReverter.handleMutationEvent(event);

    }

    @Override

    public boolean handleCommand(EditorEvent event) {

      if (event.isUndoCombo()) {

        assert responsibility.withinDirectSequence();

        settings.getInstrumentor().record(Action.UNDO);

        editorUndoManager.undo();

        return true;

      }

      if (event.isRedoCombo()) {

        assert responsibility.withinDirectSequence();

        settings.getInstrumentor().record(Action.REDO);

        editorUndoManager.redo();

        return true;

      }

      KeyCombo combo = new EventWrapper(event.asEvent()).getKeyCombo();

      switch (combo) {

        // TODO(user): deprecate CTRL_ALT_D in favour of CTRL_ALT_G, ctrl alt d

        // is a bad combo for linux as it minimizes the window in many

        // window managers.

        case CTRL_ALT_D:

        case CTRL_ALT_G:

          debugToggleDebugDialog();

          return true;

      }

      return false;

    }

    /**

     * Handles tab behaviour.

     *

     * @param start