Example #1
0
  private void renderTreeHelper(XML xml, int[] widths, int depth, int[] ltor) {
    float x = (g.width / widths[depth]) * (0.5f + ltor[depth]++);
    float y = (g.height / widths.length) * (0.5f + depth);
    xml.setFloat("x", x);
    xml.setFloat("y", y);
    if (xml.getParent() != null)
      g.line(
          xml.getParent().getFloat("x"),
          xml.getParent().getFloat("y") + RECT_HEIGHT / 2,
          x,
          y - RECT_HEIGHT / 2);
    if (xml.hasAttribute("altColor")) {
      String hexColor = xml.getString("altColor");
      g.fill(
          getColorComponent(hexColor, 0),
          getColorComponent(hexColor, 1),
          getColorComponent(hexColor, 2));
    }
    g.rect(x, y, RECT_WIDTH, RECT_HEIGHT, 4);
    g.fill(0);
    if (xml.hasAttribute("altName"))
      g.text(xml.getString("altName"), x, y, RECT_WIDTH, RECT_HEIGHT);
    else g.text(xml.getName(), x, y, RECT_WIDTH, RECT_HEIGHT);
    g.fill(255);

    XML[] children = xml.getChildren();
    for (int i = 0; i < children.length; i++)
      renderTreeHelper(children[i], widths, depth + 1, ltor);
  }
Example #2
0
 /**
  * Get a child by its name or path.
  *
  * @param name element name or path/to/element
  * @return the first matching element or null if no match
  */
 public XML getChild(String name) {
   if (name.length() > 0 && name.charAt(0) == '/') {
     throw new IllegalArgumentException("getChild() should not begin with a slash");
   }
   if (name.indexOf('/') != -1) {
     return getChildRecursive(PApplet.split(name, '/'), 0);
   }
   int childCount = getChildCount();
   for (int i = 0; i < childCount; i++) {
     XML kid = getChild(i);
     String kidName = kid.getName();
     if (kidName != null && kidName.equals(name)) {
       return kid;
     }
   }
   return null;
 }
Example #3
0
 /**
  * Get any children that match this name or path. Similar to getChild(), but will grab multiple
  * matches rather than only the first.
  *
  * @param name element name or path/to/element
  * @return array of child elements that match
  * @author processing.org
  */
 public XML[] getChildren(String name) {
   if (name.length() > 0 && name.charAt(0) == '/') {
     throw new IllegalArgumentException("getChildren() should not begin with a slash");
   }
   if (name.indexOf('/') != -1) {
     return getChildrenRecursive(PApplet.split(name, '/'), 0);
   }
   // if it's a number, do an index instead
   // (returns a single element array, since this will be a single match
   if (Character.isDigit(name.charAt(0))) {
     return new XML[] {getChild(Integer.parseInt(name))};
   }
   int childCount = getChildCount();
   XML[] matches = new XML[childCount];
   int matchCount = 0;
   for (int i = 0; i < childCount; i++) {
     XML kid = getChild(i);
     String kidName = kid.getName();
     if (kidName != null && kidName.equals(name)) {
       matches[matchCount++] = kid;
     }
   }
   return (XML[]) PApplet.subset(matches, 0, matchCount);
 }
Example #4
0
 /**
  * Internal helper function for getChild(String).
  *
  * @param items result of splitting the query on slashes
  * @param offset where in the items[] array we're currently looking
  * @return matching element or null if no match
  * @author processing.org
  */
 protected XML getChildRecursive(String[] items, int offset) {
   // if it's a number, do an index instead
   if (Character.isDigit(items[offset].charAt(0))) {
     XML kid = getChild(Integer.parseInt(items[offset]));
     if (offset == items.length - 1) {
       return kid;
     } else {
       return kid.getChildRecursive(items, offset + 1);
     }
   }
   int childCount = getChildCount();
   for (int i = 0; i < childCount; i++) {
     XML kid = getChild(i);
     String kidName = kid.getName();
     if (kidName != null && kidName.equals(items[offset])) {
       if (offset == items.length - 1) {
         return kid;
       } else {
         return kid.getChildRecursive(items, offset + 1);
       }
     }
   }
   return null;
 }
Example #5
0
  /**
   * Loads the syntax as specified in the XML
   *
   * @param xml
   */
  public void loadSyntax(XML xml) {
    // Get the list of defined styles
    XML[] styleList = xml.getChild("styles").getChildren();
    for (XML style : styleList) {
      // Make sure that this is a "style" element
      if (!style.getName().equals("style")) continue;

      // Parse the style
      TextPaint paint = new TextPaint(getPaint());
      String name = style.getContent();
      String hex = style.getString("color", "#FF000000").substring(1);
      boolean bold = style.getString("bold", "false").equals("true") ? true : false;

      // Build the TextPaint
      paint.setStyle(TextPaint.Style.FILL);
      paint.setColor(PApplet.unhex(hex));
      paint.setFakeBoldText(
          bold); // TODO what does "fake" mean? Is this something we should be concerned about?

      // Add the style
      styles.put(name, paint);
    }

    // Get the list of defined keywords
    XML[] keywords = xml.getChild("keywords").getChildren();
    ArrayList<Keyword> tempSyntax = new ArrayList<>();

    syntax = new Keyword[keywords.length];
    for (int i = 0; i < keywords.length; i++) {
      XML keyword = keywords[i];

      // Make sure that this is a "keyword" element
      if (!keyword.getName().equals("keyword")) continue;

      // Parse the keyword
      String style = keyword.getString("style", "");
      String name = keyword.getContent();
      boolean function = keyword.getString("function", "false").equals("true");

      String reference = keyword.getString("reference", "processing");
      boolean noUnderscore = keyword.getString("reference_hint", "").equals("no_underscore");

      String parentClass = keyword.getString("class", "");
      boolean staticInParentClass = Boolean.valueOf(keyword.getString("static", "false"));

      // If there is a parent class, then open that class... we don't know how to be fancier yet
      // Automatically add an underscore if the keyword is a function and doesn't have the
      // "no_underscore" hint
      String referenceTarget =
          keyword.getString(
              "reference_target",
              parentClass.length() > 0
                  ? parentClass
                  : (name + (function && !noUnderscore ? "_" : "")));

      // If this isn't a valid style, bail out
      if (!styles.containsKey(style)) continue;

      // Add the keyword
      tempSyntax.add(
          new Keyword(
              name,
              styles.get(style),
              function,
              reference,
              referenceTarget,
              parentClass,
              staticInParentClass));
    }

    syntax = new Keyword[tempSyntax.size()];

    // We need to do this because more than the half of the reported XML elements are null
    for (int i = 0; i < tempSyntax.size(); i++) {
      syntax[i] = tempSyntax.get(i);
    }

    syntaxLoaded.set(true);
  }