void xmlEvent(XMLElement element){
  flfont = element;
  initElement();
}

boolean loaded = false;
XMLElement flfont;
XMLElement[] flglyphs_xml;
FLGlyph[] flglyphs;

void initElement(){
  println(flfont);
  int g_count = 0;
  //ok, go on loading xml
  for(int i = 0; i < flfont.countChildren(); i++){
    if(flfont.getChild(i).getName().equals("FLGlyph")){
      g_count++;
    }
  }
  println(g_count);
  flglyphs_xml = new XMLElement[g_count];
  flglyphs = new FLGlyph[g_count];
  int g_i = 0;
  for(int i=0; i < flfont.countChildren();i++){
    if(flfont.getChild(i).getName().equals("FLGlyph")){
      flglyphs_xml[g_i] = flfont.getChild(i);
      flglyphs[g_i] = new FLGlyph();
      XMLElement[] c_xml = new XMLElement[flglyphs_xml[g_i].countChildren()];
        println("c_xml.length = "+c_xml.length);
      for(int c_i = 0; c_i<flglyphs_xml[g_i].countChildren(); c_i++){
        c_xml[c_i] = flglyphs_xml[g_i].getChild(c_i);
        FLContour c = new FLContour();
        flglyphs[g_i].addContour(c);
        XMLElement[] n_xml =new XMLElement[c_xml[c_i].countChildren()];
        for(int n_i=0; n_i<c_xml[c_i].countChildren(); n_i++){
          n_xml[n_i] = c_xml[c_i].getChild(n_i);
          if(n_xml[n_i].countChildren() == 1){
            XMLElement pa_xml = n_xml[n_i].getChild(0);
            float x = pa_xml.getFloatAttribute("x");
            float y = pa_xml.getFloatAttribute("y");
            FLpt pa = new FLpt(x, y);
            c.addNode(new FLNode(pa));
          } else {
            XMLElement pa_xml = n_xml[n_i].getChild(0);
            XMLElement pb_xml = n_xml[n_i].getChild(1);
            XMLElement pc_xml = n_xml[n_i].getChild(2);
            FLpt pa = new FLpt(pa_xml.getFloatAttribute("x"),
                               pa_xml.getFloatAttribute("y"));
            FLpt pb = new FLpt(pb_xml.getFloatAttribute("x"),
                               pb_xml.getFloatAttribute("y"));
            FLpt pc = new FLpt(pc_xml.getFloatAttribute("x"),
                               pc_xml.getFloatAttribute("y"));
            c.addNode(new FLNode(pa, pb, pc));
          }
        }
      }
      g_i++;
    }
  }
  loaded = true;
}

class FLGlyph{
  ArrayList contours;
  FLGlyph(){
    contours = new ArrayList();
  }
  void addContour(FLContour c){
    contours.add(c);
  }
  void draw(color fl){
    noStroke();
    fill(fl); // assuming that the first shape is the larger shape, in which there may be
              // holes defined by the other contours
    Iterator it = contours.iterator();
    while(it.hasNext()){
      FLContour c = (FLContour)(it.next());
      c.draw();
      fill(bg); // the rest are holes. i don't know how to draw real holes, 
                // so background colored shapes will have to do.
    }
  }
  void draw(float x, float y, float scaler, float t){
    Iterator c_it = contours.iterator();
    int c_i =0;
    while(c_it.hasNext()){
      FLContour c = (FLContour)(c_it.next());
      c.draw(x, y, scaler, t);
      //fill(bg); // the rest are holes. i don't know how to draw real holes, 
                // so background colored shapes will have to do.
      c_i++;
    }
  }
}

class FLContour{
  ArrayList nodes;
  FLContour(){
    nodes = new ArrayList();
  }
  void addNode(FLNode n){
    nodes.add(n);
  }
  void draw(){
    beginShape();
    Iterator it = nodes.iterator();
    while(it.hasNext()){
      FLNode n = (FLNode)(it.next());
      n.draw();
    }
    endShape();
  }
  void draw(float x, float y, float scaler, float t){
    beginShape();
    Iterator n_it = nodes.iterator();
    while(n_it.hasNext()){
      FLNode n = (FLNode)(n_it.next());
      n.draw(x, y, scaler, t);
    }
    FLNode n = (FLNode)(nodes.get(0));
    n.draw(x, y, scaler, t);
    endShape();
  }
}

class FLNode{
  int length;
  FLpt[] pts;
  FLNode(FLpt a){
    length = 1;
    pts = new FLpt[1];
    pts[0] = a;
  }
  FLNode(FLpt a, FLpt b, FLpt c){
    length = 3;
    pts = new FLpt[3];
    pts[0] = a;
    pts[1] = b;
    pts[2] = c;
  }
  void draw(){
    if(length == 1){
      vertex(pts[0].x, pts[0].y);
    } else {
      bezierVertex(pts[0].x, pts[0].y, pts[1].x, pts[1].y, pts[2].x, pts[2].y);
    }
  }
  void draw(float x, float y, float scaler, float t){
    if(length == 1){
      float scl_d0 = scaler*sqrt(sq(pts[0].x)+sq(pts[0].y));
      float t0 = atan2(pts[0].y, pts[0].x);
      float rx0 = x+scl_d0*cos(t0+t);
      float ry0 = y+scl_d0*sin(t0+t);
      vertex(rx0, ry0);
      //vertex(x+scaler*pts[0].x, y+scaler*pts[0].y);
    } else {
      float scl_d0 = scaler*sqrt(sq(pts[0].x)+sq(pts[0].y));
      float t0 = atan2(pts[0].y, pts[0].x);
      float rx0 = x+scl_d0*cos(t0+t);
      float ry0 = y+scl_d0*sin(t0+t);
      float scl_d1 = scaler*sqrt(sq(pts[1].x)+sq(pts[1].y));
      float t1 = atan2(pts[1].y, pts[1].x);
      float rx1 = x+scl_d1*cos(t1+t);
      float ry1 = y+scl_d1*sin(t1+t);
      float scl_d2 = sqrt(sq(pts[2].x)+sq(pts[2].y));
      float t2 = atan2(pts[2].y, pts[2].x);
      float rx2 = x+scl_d2*cos(t2+t);
      float ry2 = y+scl_d2*sin(t2+t);
      //bezierVertex(rx0, ry0, rx1, ry1, rx2, ry2);
      bezierVertex(rx1, ry1, rx2, ry2, rx0, ry0);
    }
  }
}

class FLpt{
  float x, y;
  FLpt(float x, float y){
    this.x = x;
    this.y = y;
  } 
}


XMLElement findChildByTagName(String tagName, XMLElement parent){
  XMLElement needle = new XMLElement("notfound");
  for(int i = 0; i < parent.countChildren();i++){
    if(parent.getChild(i).getName().equals(tagName)){
      needle = parent.getChild(i);
      break;
    }
  }
  return needle;
}