InlineAnchorLiveRenderer.java

/**
 * Copyright 2010 Google Inc.
 *
 * Licensed 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.
 */

package org.waveprotocol.wave.client.wavepanel.render;

import com.google.gwt.dom.client.Document;
import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.Style.Display;

import org.waveprotocol.wave.client.common.util.DomHelper;
import org.waveprotocol.wave.client.common.util.LinkedPruningSequenceMap;
import org.waveprotocol.wave.client.common.util.SequenceElement;
import org.waveprotocol.wave.client.common.util.VolatileComparable;
import org.waveprotocol.wave.client.doodad.DoodadInstallers.BlipInstaller;
import org.waveprotocol.wave.client.editor.NodeEventHandler;
import org.waveprotocol.wave.client.editor.RenderingMutationHandler;
import org.waveprotocol.wave.client.editor.content.ContentElement;
import org.waveprotocol.wave.client.editor.content.Registries;
import org.waveprotocol.wave.client.editor.content.misc.ChunkyElementHandler;
import org.waveprotocol.wave.client.editor.event.EditorEvent;
import org.waveprotocol.wave.client.editor.selection.content.SelectionUtil;
import org.waveprotocol.wave.client.uibuilder.BuilderHelper;
import org.waveprotocol.wave.client.wavepanel.view.AnchorView;
import org.waveprotocol.wave.client.wavepanel.view.ViewIdMapper;
import org.waveprotocol.wave.client.wavepanel.view.View.Type;
import org.waveprotocol.wave.client.wavepanel.view.dom.DomAsViewProvider;
import org.waveprotocol.wave.client.wavepanel.view.dom.full.TypeCodes;
import org.waveprotocol.wave.model.conversation.Blips;
import org.waveprotocol.wave.model.conversation.Conversation;
import org.waveprotocol.wave.model.conversation.ConversationBlip;
import org.waveprotocol.wave.model.util.CollectionUtils;
import org.waveprotocol.wave.model.util.IdentitySet;
import org.waveprotocol.wave.model.util.StringMap;
import org.waveprotocol.wave.model.util.ReadableIdentitySet.Proc;
import org.waveprotocol.wave.model.wave.Wavelet;

/**
 * Renders a reply element as an anchor view.
 *
 */
public final class InlineAnchorLiveRenderer extends RenderingMutationHandler {

  interface AnchorHandler {
    void onAnchorAddedBefore(ConversationBlip blip, ReplyDoodad ref, ReplyDoodad anchor);

    void onAnchorRemoved(ConversationBlip blip, ReplyDoodad anchor);
  }

  public final class ReplyDoodad implements VolatileComparable<ReplyDoodad> {
    private final ContentElement el;
    private final String threadId;
    private AnchorView anchor;

    public ReplyDoodad(ContentElement el, String id) {
      this.el = el;
      this.threadId = id;
    }

    public ConversationBlip getBlip() {
      return blip;
    }

    public String getId() {
      return threadId;
    }

    public AnchorView getAnchor() {
      if (anchor == null) {
        anchor = views.asAnchor(el.getImplNodelet());
      }
      return anchor;
    }

    public void setDomId(String id) {
      if (id != null) {
        el.getImplNodelet().setId(id);
        el.getImplNodelet().setAttribute(
            BuilderHelper.KIND_ATTRIBUTE, TypeCodes.kind(Type.ANCHOR));
      } else {
        el.getImplNodelet().setId(null);
        el.getImplNodelet().removeAttribute(BuilderHelper.KIND_ATTRIBUTE);
      }
    }

    @Override
    public int compareTo(ReplyDoodad o) {
      return el.compareTo(o.el);
    }

    @Override
    public boolean isComparable() {
      return el.isComparable();
    }

    @Override
    public boolean equals(Object obj) {
      return (obj == this || ((obj instanceof ReplyDoodad) && el.equals(((ReplyDoodad) obj).el)));
    }
  }

  public static BlipInstaller installer(final ViewIdMapper viewIdMapper,
      final AnchorHandler manager, final DomAsViewProvider views) {
    return new BlipInstaller() {
      @Override
      public void install(Wavelet w, Conversation c, ConversationBlip b, Registries r) {
        InlineAnchorLiveRenderer renderer =
            new InlineAnchorLiveRenderer(viewIdMapper, b, manager, views);

        r.getElementHandlerRegistry().registerRenderingMutationHandler(
            Blips.THREAD_INLINE_ANCHOR_TAGNAME, renderer);
        r.getElementHandlerRegistry().registerEventHandler(
            Blips.THREAD_INLINE_ANCHOR_TAGNAME, ANCHOR_HANDLER);
      }
    };
  }

  /**
   * Event handling logic for inline thread doodads
   */
  private final static NodeEventHandler ANCHOR_HANDLER = new ChunkyElementHandler() {
    @Override
    public boolean handleClick(ContentElement element, EditorEvent event) {
      SelectionUtil.placeCaretBeforeElement(element.getSelectionHelper(), element);
      return true;
    }

    @Override
    public boolean handleBackspaceAfterNode(ContentElement element, EditorEvent event) {
      // Do nothing, and report gesture as handled.
      return true;
    }

    @Override
    public boolean handleDeleteBeforeNode(ContentElement element, EditorEvent event) {
      // Do nothing, and report gesture as handled.
      return true;
    }
  };

  /** Reveals DOM elements as semantic views. */
  private final DomAsViewProvider views;

  /** Blip whose anchors this renderer renders. */
  private final ConversationBlip blip;

  /** View id mapper used to look up view id from model object. */
  private final ViewIdMapper viewIdMapper;

  //
  // Local state needed for providing AnchorHandler events through incremental
  // processing.
  //
  // Note that it might be possible to encode this state as extra attributes /
  // properties on the view itself, which may have benefits.
  //

  /** Anchors that have no predecessor with the same thread id. Lazily created. */
  private StringMap<ReplyDoodad> canonicals;

  /** Anchors that have a predecessor with the same thread id. Lazily created. */
  private IdentitySet<ReplyDoodad> duplicates;

  /** Ordering of canonical anchors in this document. Lazily created. */
  private LinkedPruningSequenceMap<ReplyDoodad, ReplyDoodad> canonicalOrder;

  /** Option listener to handle canonical anchor addition and removal. */
  private final AnchorHandler handler;

  static class CanonicalAnchorFinder implements Proc<ReplyDoodad> {
    /** Id of the anchor to find. */
    private final String id;
    /** Current minimum anchor with id {@code id}. */
    private ReplyDoodad min;

    CanonicalAnchorFinder(String id) {
      this.id = id;
    }

    static ReplyDoodad findMinimum(String id, IdentitySet<ReplyDoodad> anchors) {
      CanonicalAnchorFinder finder = new CanonicalAnchorFinder(id);
      anchors.each(finder);
      return finder.min;
    }

    @Override
    public void apply(ReplyDoodad duplicate) {
      if (duplicate.getId().equals(id)) {
        min = (min == null || duplicate.compareTo(min) < 0) ? duplicate : min;
      }
    }
  }

  private InlineAnchorLiveRenderer(ViewIdMapper viewIdMapper, ConversationBlip blip,
      AnchorHandler h, DomAsViewProvider views) {
    this.viewIdMapper = viewIdMapper;
    this.blip = blip;
    this.handler = h;
    this.views = views;
  }

  private IdentitySet<ReplyDoodad> getDuplicates() {
    if (duplicates == null) {
      duplicates = CollectionUtils.createIdentitySet();
    }
    return duplicates;
  }

  public StringMap<ReplyDoodad> getCanonicals() {
    if (canonicals == null) {
      canonicals = CollectionUtils.createStringMap();
    }
    return canonicals;
  }

  private LinkedPruningSequenceMap<ReplyDoodad, ReplyDoodad> getCanonicalOrder() {
    if (canonicalOrder == null) {
      canonicalOrder = LinkedPruningSequenceMap.create();
    }
    return canonicalOrder;
  }

  private void add(ReplyDoodad anchor) {
    ReplyDoodad existing = getCanonicals().get(anchor.getId());
    if (existing == null) {
      addCanonical(anchor);
    } else if (anchor.compareTo(existing) < 0) {
      // New anchor occurs earlier. Replace.
      removeCanonical(existing);
      getDuplicates().add(existing);
      addCanonical(anchor);
    } else {
      // New anchor occurs later. Ignore.
      getDuplicates().add(anchor);
    }
  }

  private void remove(ReplyDoodad anchor) {
    ReplyDoodad existing = getCanonicals().get(anchor.getId());
    if (!anchor.equals(existing)) {
      // Non-canonical removal.
      getDuplicates().remove(anchor);
    } else {
      removeCanonical(anchor);

      // Is there a duplicate to be promoted to a canonical?
      ReplyDoodad toPromote = CanonicalAnchorFinder.findMinimum(anchor.getId(), getDuplicates());
      if (toPromote != null) {
        getDuplicates().remove(toPromote);
        addCanonical(toPromote);
      }
    }
  }

  private void addCanonical(ReplyDoodad anchor) {
    getCanonicals().put(anchor.getId(), anchor);
    getCanonicalOrder().put(anchor, anchor);

    // Find next canonical, remembering to eliminate inconvenient circularity.
    SequenceElement<ReplyDoodad> nextNode = getCanonicalOrder().getElement(anchor).getNext();
    ReplyDoodad next = (nextNode != getCanonicalOrder().getFirst()) ? nextNode.value() : null;
    anchor.setDomId(viewIdMapper.inlineAnchorOf(blip, anchor.getId()));
    handler.onAnchorAddedBefore(blip, next, anchor);
  }

  private void removeCanonical(ReplyDoodad anchor) {
    getCanonicals().remove(anchor.getId());
    getCanonicalOrder().remove(anchor);
    handler.onAnchorRemoved(blip, anchor);
    // Clear DOM id only after handler processing.
    anchor.setDomId(null);
  }

  @Override
  public Element createDomImpl(Renderable element) {
    // HTML does not allow block elements inside inline elements, so it has to
    // be divs all the way, not spans.
    Element e = Document.get().createDivElement();
    e.getStyle().setDisplay(Display.INLINE);
    // Do the things that the doodad API should be doing by default.
    DomHelper.setContentEditable(e, false, false);
    DomHelper.makeUnselectable(e);
    // ContentElement attempts this, and fails, so we have to do this ourselves.
    e.getStyle().setProperty("whiteSpace", "normal");
    e.getStyle().setProperty("lineHeight", "normal");
    return e;
  }

  @Override
  public void onActivatedSubtree(ContentElement element) {
    String id = element.getAttribute(Blips.THREAD_INLINE_ANCHOR_ID_ATTR);
    if (id != null) {
      add(new ReplyDoodad(element, id));
    }
  }

  @Override
  public void onDeactivated(ContentElement element) {
    String id = element.getAttribute(Blips.THREAD_INLINE_ANCHOR_ID_ATTR);
    if (id != null) {
      remove(new ReplyDoodad(element, id));
    }
  }

  //
  // This renderer is only intended for a static rendering,
  // and is not intended for keeping that rendering live in response to events.
  // Since there is no API for static renderers (all renderers must be
  // implemented as mutation handlers), the only way to prevent misuse is to
  // detect it dynamically.
  //

  @Override
  public void onAttributeModified(ContentElement element, String name, String oldValue,
      String newValue) {
    if (Blips.THREAD_INLINE_ANCHOR_ID_ATTR.equals(name)) {
      if (oldValue != null) {
        remove(new ReplyDoodad(element, oldValue));
      }
      if (newValue != null) {
        add(new ReplyDoodad(element, newValue));
      }
    }
  }
}