WikiElement.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2015 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.zkoss.text;
 
import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import org.turro.string.Strings;
import org.turro.elephant.context.ElephantContext;
import org.zkoss.zul.impl.InputElement;
 
public class WikiElement {
  
  public static final String[]
          NON_BLOCK_ELEMENTS = { "img" };
 
  private int startElement, endElement, selectionStart, selectionEnd;
  private String text, tag, content, avoid[];
  private InputElement input;
  private boolean creating;
  private HashMap<String, String> attributes = new HashMap<>();
  
  public WikiElement(int selectionStart, InputElement input, String tag) {
    this.selectionStart = selectionStart;
    this.selectionEnd = selectionStart;
    this.input = input;
    this.avoid = null;
    this.text = input.getText();
    initializeTag(tag);
  }
 
  public WikiElement(int selectionStart, int selectionEnd, InputElement input) {
    this(selectionStart, selectionEnd, input, null);
  }
 
  public WikiElement(int selectionStart, int selectionEnd, InputElement input, String avoid[]) {
    this.selectionStart = selectionStart;
    this.selectionEnd = selectionEnd;
    this.input = input;
    this.avoid = avoid;
    this.text = input.getText();
    initialize();
  }
 
  public void forgetAndCreate(String newTag) {
    this.tag = newTag;
    attributes.clear();
    creating = true;
  }
  
  public void setContent(String content) {
    this.content = content;
  }
  
  public boolean inside() {
    return !Strings.isBlank(tag);
  }
 
  public boolean isTag(String tag) {
    return this.tag == null ? false : this.tag.equals(tag);
  }
 
  public boolean isCreating() {
    return creating;
  }
  
  public HashMap<String, String> getAttributes() {
    return attributes;
  }
 
  public void addNoValuedAttribute(String value) {
    attributes.put(value, "no-value");
  }
  
  public String getFistNoneValued() {
    for(String s : attributes.keySet()) {
      if(attributes.get(s).equals("no-value")) {
        return s;
      }
    }
    return "";
  }
  
  public void addClass(String sclass) {
    String classes = attributes.get("&class");
    if(classes != null) {
      if(!classes.contains(sclass)) {
        classes += " " + sclass;
      }
    } else {
      classes = sclass;
    }
    attributes.put("&class", classes);
  }
  
  public void removeValuedAttributes() {
    Iterator<String> it = attributes.keySet().iterator();
    while(it.hasNext()) {
      String v = attributes.get(it.next());
      if(!"no-value".equals(v)) {
        it.remove();
      }
    }
  }
  
  private void initialize() {
    startElement = avoided();
    if(startElement > -1 && text.charAt(startElement + 1) != '/') {
      endElement = text.substring(startElement).indexOf("]") + startElement;
      int p = text.substring(startElement, endElement).indexOf("(");
      tag = Strings.extract(text.substring(startElement + 1), "([a-z0-9]+)");
      if(p > -1) {
        tag = text.substring(startElement + 1, startElement + p);
        String attr = text.substring(startElement + p + 1, endElement - 1);
        if(attr != null) {
          for(String s : attr.split(",")) {
            int pa = s.indexOf(":");
            if(pa > 1) {
              if(s.charAt(pa - 1) == '\\') {
                int pa2 = s.indexOf(":", pa + 1);
                if(pa2 > -1) {
                  pa += pa2;
                } else {
                  pa = -1;
                }
              }
            }
            if(pa == -1) {
              attributes.put(s, "no-value");
            } else {
              attributes.put(s.substring(0, pa), s.substring(pa + 1).replaceAll("\\:", "\\\\\\:"));
            }
          }
        }
      }
    }
  }
  
  private void initializeTag(String tag) {
    startElement = text.substring(0, selectionStart).lastIndexOf("[" + tag);
    endElement = text.indexOf("]", startElement);
    this.tag = tag;
    if(startElement > -1 && startElement < selectionStart && selectionStart < endElement) {
      
    } else {
      forgetAndCreate(tag);
    }
  }
  
  public boolean render() {
    int pointer = creating ? selectionStart : startElement;
    if(!Strings.isBlank(tag)) {
      if(!creating) {
        input.setSelectedText(pointer, endElement + 1, "", false);
      }
      String tagString = elementString();
      input.setSelectedText(pointer, pointer, tagString, false);
      if(creating) {
        if(!Strings.isBlank(content)) {
          pointer += tagString.length();
          input.setSelectedText(pointer, pointer, content, false);
          pointer += content.length();
        }
        input.setSelectedText(pointer, pointer, "[/" + tag + "]", false);
      }
      return true;
    }
    return false;
  }
 
  private String elementString() {
    StringBuilder sb = new StringBuilder();
    sb.append("[").append(tag);
    boolean firstDone = false;
    if(!attributes.isEmpty()) {
      sb.append("(");
      // start with no-value
      for(String k : attributes.keySet()) {
        String v = attributes.get(k);
        if("no-value".equals(v)) {
          if(firstDone) {
            sb.append(",");
          }
          sb.append(k);
          firstDone = true;
        }
      }
      for(String k : attributes.keySet()) {
        String v = attributes.get(k);
        if(!"no-value".equals(v)) {
          if(firstDone) {
            sb.append(",");
          }
          sb.append(k);
          sb.append(":").append(v.replaceAll("\\:", "\\\\\\:"));
          firstDone = true;
        }
      }
      sb.append(")");
    }
    sb.append("]");
    return sb.toString();
  }
 
  public boolean renderImage(File image) {
    if(image != null) {
      int pointer = creating ? selectionStart : startElement;
      if(!Strings.isBlank(tag)) {
        if(!creating) {
          input.setSelectedText(pointer, endElement + 1, "", false);
        }
        String tagString = imageString(image);
        input.setSelectedText(pointer, pointer, tagString, false);
      }
      return true;
    }
    return false;
  }
 
  private String imageString(File image) {
    StringBuilder sb = new StringBuilder();
    sb.append("[").append(tag).append(" ")
            .append(ElephantContext.getRootWebPath() + ElephantContext.getRelativePath(image.getAbsolutePath()))
            .append("]");
    return sb.toString();
  }
 
  private int avoided() {
    int start = text.substring(0, selectionStart).lastIndexOf("[");
    if(avoid != null) {
      while(start > -1) {
        boolean accept = true;
        for(String s : avoid) {
          if(text.substring(start + 1).startsWith(s)) {
            accept = false;
            break;
          }
        }
        if(accept || start == 0) {
          break;
        } else {
          start = text.substring(0, start - 1).lastIndexOf("[");
        }
      }
    }
    return start;
  }
 
}