Navigator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.impl.navigation;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.SortedSet;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.impl.context.ContextAdapter;
import org.turro.elephant.web.ElContext;
import org.turro.elephant.web.ElContextMap;
 
public class Navigator {
 
  protected IConstructor constructor;
  protected ElContext context, current;
  protected SortedSet<ElContext> contexts;
  protected int level, levelUsed, preloaded;
  protected boolean dynamicLoad, showCurrent, showTitle, drawDecorators = true;
  protected NavigatorType type;
  protected String cssClass;
 
  public Navigator(ElContext context) {
    this.context = context;
    this.level = context.getLevel();
  }
 
  public void initialize() {
    this.constructor = Application.getApplication().getConstructor();
    this.current = constructor.getCurrentContext();
    if(current != null) {
      if(type == NavigatorType.FLOATING) {
        this.contexts = new ContextAdapter(context.getChildren()).getVisible();
      }
      else {
        levelUsed = level;
        if(type == NavigatorType.TRAVERSAL) {
          levelUsed--;
        }
        this.contexts = ElContextMap.getContexts(current.getPath(), levelUsed);
      }
      if(cssClass == null) {
        cssClass = type.name().toLowerCase();
      }
    }
  }
 
  public boolean somethingToShow() {
    return (contexts != null) && (!contexts.isEmpty());
  }
 
  public void draw() throws IOException {
    if (!contexts.isEmpty()) {
      PrintWriter out = constructor.getOut();
      out.print(getStart());
      if (type == NavigatorType.LOCATION) {
        ElContext[] ancestor = current.getAncestors().toArray(new ElContext[0]);
        for (ElContext ancestor1 : ancestor) {
          out.print("<a href='" + ancestor1.getWebPath() + "'>" + ancestor1.getName() + "</a>");
        }
        // TODO: provide aditional entries comming from elements, JavaScript?
        out.print("<span id='ext_location'></span>");
//        if (dynamicLoad) {
//          constructor.addOnLoadedJavaScript("$$('.location a').each(function(node) { prepareNavigator('" + constructor.getRootWebPath() + "', node, 0); });");
//        }
      } else if (type == NavigatorType.TRAVERSAL) {
        int levelUsed = level - 1;
        ElContext previous = getPrevious(current),
                next = getNext(current, true);
        int currLevel = current.getLevel();
        out.print("<table width='100%'><tr><td width='35%' align='left'>");
        if (previous != null && ((levelUsed > 0 && currLevel > levelUsed) || levelUsed == 0)) {
          out.print("<span id='trav-previous'><a href='" + previous.getWebPath() + "'>" + previous.getName() + "</a></span>");
        }
        out.print("</td><td width='30%' align='center'>");
        if (current.getParent() != null && !current.getParent().equals(previous) && ((levelUsed > 0 && currLevel > levelUsed) || levelUsed == 0)) {
          out.print("<span id='trav-parent'><a href='" + current.getParent().getWebPath() + "'>" + current.getParent().getName() + "</a></span>");
        }
        out.print("</td><td width='35%' align='right'>");
        if (next != null) {
          out.print("<span id='trav-next'><a href='" + next.getWebPath() + "'>" + next.getName() + "</a></span>");
        }
        out.print("</td></tr></table>");
        if (showTitle) {
          out.print("<div class='context-title'>" + current.getName() + "</div>");
        }
//        if (dynamicLoad) {
//          constructor.addOnLoadedJavaScript("$$('.traversal a').each(function(node) { prepareNavigator('" + constructor.getRootWebPath() + "', node, 0); });");
//        }
      } else if (type == NavigatorType.FLOATING) {
        if (drawDecorators && type != NavigatorType.TABULATOR) {
          out.print("<div class='" + cssClass + "_top'><div></div></div>");
        }
        out.print(getStartBody());
        for (ElContext ctx : contexts) {
          if (ctx.canDisplay()) {
            renderContext(out, ctx, current);
            doChildren(out, ctx, current, preloaded);
            out.print("</li>");
          }
        }
        out.print(getEndBody());
        if (drawDecorators && type != NavigatorType.TABULATOR) {
          out.print("<div class='" + cssClass + "_bottom'><div></div></div>");
        }
      } else {
        String offsetLeft = "0";
        if (drawDecorators && type != NavigatorType.TABULATOR) {
          out.print("<div class='" + cssClass + "_top'><div></div></div>");
        }
        out.print(getStartBody());
        for (ElContext ctx : contexts) {
          if (ctx.canDisplay()) {
            renderContext(out, ctx, current);
            doChildren(out, ctx, current, preloaded);
            out.print("</li>");
          }
        }
        out.print(getEndBody());
        if (drawDecorators && type != NavigatorType.TABULATOR) {
          out.print("<div class='" + cssClass + "_bottom'><div></div></div>");
          offsetLeft = "100";
        }
        //TODO: check roles and make children also sortable
        //constructor.addOnLoadedJavaScript("Sortable.create('id_" + cssClass +
        //        "' " + (type == NavigatorType.TABULATOR ? ",{constraint: 'horizontal'}" : "") + ")");
        if (dynamicLoad && type == NavigatorType.TABULATOR) {
          //constructor.addOnLoadedJavaScript("$$('." + cssClass + " a').each(function(node) { prepareNavigator('" + constructor.getRootWebPath() + "', node, " + offsetLeft + "); });");
          constructor.addOnLoadedJavaScript("$('." + cssClass + "').find('a').each(function(index) { prepareNavigator('" + ElephantContext.getRootWebPath() + "', $(this), " + offsetLeft + "); });");
        }
      }
      out.print(getEnd());
    }
  }
 
  public Collection<ContextNavigatorItem> contexts() throws IOException {
    ArrayList<ContextNavigatorItem> list = new ArrayList<>();
    if(current != null) {
      ElContext elCurrent = ElContextMap.getContext(current.getPath());
      if(elCurrent != null) {
        if (type == NavigatorType.LOCATION) {
          for(ElContext ctx : elCurrent.getAncestors()) {
            list.add(new ContextNavigatorItem(ctx, elCurrent));
          }
        } else if (type == NavigatorType.TRAVERSAL) {
          int levelUsed = level - 1;
          ElContext previous = elCurrent.getPrevious(),
                  next = elCurrent.getNext(true);
          int currLevel = elCurrent.getLevel();
          if (previous != null && ((levelUsed > 0 && currLevel > levelUsed) || levelUsed == 0)) {
            list.add(new ContextNavigatorItem(previous, elCurrent));
          } else {
            list.add(null);
          }
          if (elCurrent.getParent() != null && !elCurrent.getParent().equals(previous) && ((levelUsed > 0 && currLevel > levelUsed) || levelUsed == 0)) {
            list.add(new ContextNavigatorItem(elCurrent.getParent(), elCurrent));
          } else {
            list.add(null);
          }
          if (next != null) {
            list.add(new ContextNavigatorItem(next, elCurrent));
          } else {
            list.add(null);
          }
        } else if (type == NavigatorType.FLOATING) {
          for(ElContext ctx : elCurrent.getVisibleChildren()) {
            if (ctx.canDisplay()) {
              list.add(new ContextNavigatorItem(ctx, elCurrent));
            }
          }
        } else {
          for(ElContext ctx : ElContextMap.getContexts(elCurrent.getPath(), level)) {
            if (ctx.canDisplay()) {
              list.add(new ContextNavigatorItem(ctx, elCurrent));
            }
          }
        }
      }
    }
    return list;
  }
 
  private void doChildren(PrintWriter out, ElContext parent, ElContext current, int preload) {
    if (preload <= 0 && !(showCurrent && parent.inPath(current))) {
      return;
    }
    SortedSet<ElContext> children = parent.getChildren();
    if (children.size() > 0) {
      out.print("<ul>");
      for (ElContext ic : children) {
        if (ic.canDisplay()) {
          renderContext(out, ic, current);
          doChildren(out, ic, current, preload - 1);
          out.print("</li>");
        }
      }
      out.print("</ul>");
    }
  }
 
  public String getStart() {
    return "<div class='" + cssClass + "'>";
  }
 
  public String getEnd() {
    return "</div>";
  }
 
  public String getStartBody() {
    return "<ul id='id_" + cssClass + "' class='" + cssClass + "'>";
  }
 
  public String getEndBody() {
    return "</ul>";
  }
 
  private void renderContext(PrintWriter out, ElContext context, ElContext current) {
    //TODO: add level to cssClass    
    String classCss = (context.equals(current) ? " class='active'" : (context.inPath(current) ? " class='inpath'" : (!context.isInRole() ? " class='protected'" : "")));
    out.print("<li" + classCss + ">");
    out.print("<a" + classCss + " href='" + context.getWebPath() + "'>");
    out.print(context.getName());
    out.print("</a>");
  }
 
  private ElContext getPrevious(ElContext current) {
    if (current == null) {
      return null;
    }
    if (current.getParent() != null) {
      SortedSet<ElContext> siblings = new ContextAdapter(current.getParent().getChildren()).getVisible();
      for (ElContext ctx : siblings) {
        if(current.equals(ctx) && !ctx.equals(siblings.first()) && ctx.canDisplay()) {
          return getLastChildren(ctx);
        }
      }
      return current.getParent();
    }
    return null;
  }
 
  private ElContext getLastChildren(ElContext current) {
    SortedSet<ElContext> children = new ContextAdapter(current.getChildren()).getVisible();
    if(children.size() > 0) {
      return getLastChildren(children.last());
    }
    return current;
  }
 
  private ElContext getNext(ElContext current, boolean doChildren) {
    if (current == null) {
      return null;
    }
    if (doChildren) {
      SortedSet<ElContext> children = new ContextAdapter(current.getChildren()).getVisible();
      if (children.size() > 0) {
        return children.first();
      }
    }
    if (current.getParent() != null) {
      SortedSet<ElContext> siblings = new ContextAdapter(current.getParent().getChildren()).getVisible();
      for (ElContext ctx : siblings) {
        if (current.equals(ctx) && !ctx.equals(siblings.last())) {
          return ctx;
        }
      }
    }
    return getNext(current.getParent(), false);
  }
 
  public NavigatorType getType() {
    return type;
  }
 
  public void setType(NavigatorType type) {
    this.type = type;
  }
 
  public void setTypeString(String typeStr) {
    for (NavigatorType nt : NavigatorType.values()) {
      if (nt.name().toLowerCase().equals(typeStr.toLowerCase())) {
        this.type = nt;
      }
    }
  }
 
  public String getCssClass() {
    return cssClass;
  }
 
  public void setCssClass(String cssClass) {
    this.cssClass = cssClass;
  }
 
  public boolean isDrawDecorators() {
    return drawDecorators;
  }
 
  public void setDrawDecorators(boolean drawDecorators) {
    this.drawDecorators = drawDecorators;
  }
 
  public int getPreloaded() {
    return preloaded;
  }
 
  public void setPreloaded(int preloaded) {
    this.preloaded = preloaded;
  }
 
  public boolean isDynamicLoad() {
    return dynamicLoad;
  }
 
  public void setDynamicLoad(boolean dynamicLoad) {
    this.dynamicLoad = dynamicLoad;
  }
 
  public int getLevel() {
    return level;
  }
 
  public void setLevel(int level) {
    this.level = level;
  }
 
  public boolean isShowCurrent() {
    return showCurrent;
  }
 
  public void setShowCurrent(boolean showCurrent) {
    this.showCurrent = showCurrent;
  }
 
  public boolean isShowTitle() {
    return showTitle;
  }
 
  public void setShowTitle(boolean showTitle) {
    this.showTitle = showTitle;
  }
  
  public void drawTabulator(int level) throws IOException {
    setType(NavigatorType.TABULATOR);
    setCssClass(null);
    setLevel(level);
    initialize();
    draw();
  }
  
  public void drawLocation() throws IOException {
    setType(NavigatorType.LOCATION);
    setCssClass(null);
    initialize();
    draw();
  }
  
  public void drawOptions(boolean decorators, int level, int preloaded, boolean current) throws IOException {
    setType(NavigatorType.OPTIONS);
    setCssClass(null);
    setDrawDecorators(decorators);
    setLevel(level);
    setPreloaded(preloaded);
    setShowCurrent(current);
    initialize();
    draw();
  }
  
  public boolean hasOptions(int level, int preloaded, boolean current) throws IOException {
    setType(NavigatorType.OPTIONS);
    setCssClass(null);
    setLevel(level);
    setPreloaded(preloaded);
    setShowCurrent(current);
    initialize();
    for(ElContext ctx : contexts) {
      if (ctx.canDisplay()) {
        return true;
      }
    }
    return false; //contexts.length > 0;
  }
  
  public void drawTraversal(boolean title) throws IOException {
    setType(NavigatorType.TRAVERSAL);
    setCssClass(null);
    setShowTitle(title);
    initialize();
    draw();
  }
  
  public Collection<ContextNavigatorItem> contextTabulator(int level) throws IOException {
    setType(NavigatorType.TABULATOR);
    setCssClass(null);
    setLevel(level);
    initialize();
    return contexts();
  }
  
  public Collection<ContextNavigatorItem> contextLocation() throws IOException {
    setType(NavigatorType.LOCATION);
    setCssClass(null);
    initialize();
    return contexts();
  }
  
  public Collection<ContextNavigatorItem> contextOptions(int level, int preloaded, boolean current) throws IOException {
    setType(NavigatorType.OPTIONS);
    setCssClass(null);
    setDrawDecorators(false);
    setLevel(level);
    setPreloaded(preloaded);
    setShowCurrent(current);
    initialize();
    return contexts();
  }
  
  public Collection<ContextNavigatorItem> contextTraversal() throws IOException {
    setType(NavigatorType.TRAVERSAL);
    setCssClass(null);
    initialize();
    return contexts();
  }
  
}