// component in SkanaarTexturizer (c)2005 Daniel Kallin
// Detta är superklassen till alla filter
// Den innehåller alla variabler och metoder som är obligatoriska i filter
//----------------------------------------------------------------
class TextureFilter {
  int sourceCount; // Antalet källfilter
  float x, y; // Positionen ochav filtrets ikon i trädstrukturen
  float fx, fy; // kraftvektor på filtrets ikon
  int radius = 8;
  int handleRadius = 3;
  String name; // TexturFiltrets namn på skärmen
  String description;
  color borderColor; // ikonens kantfärg
  TextureFilter[] sources;
  String[] sourceDescriptions;
  float[][] sourceKnobs;
  Attribute[] attributes;
  boolean[] selectedSources;
  boolean selected = false;
  boolean deleteMe = false;
  //--Metoder-------------------------------------
  TextureFilter(String name, int sourceCount, int attributeCount){
    this(name,sourceCount,attributeCount,"");
  }
  //--Metoder-------------------------------------
  TextureFilter(String name, int sourceCount, int attributeCount, String description){
    this.sourceCount = sourceCount;
    this.name = name;
    this.description = description;
    borderColor = color(0);
    x = rootX + (int) random(-guiWidth/3,guiWidth/3);
    y = rootY + (int) random(0,guiWidth/2);
    sources = new TextureFilter[sourceCount];
    sourceDescriptions = new String[sourceCount];
    sourceKnobs = new float[sourceCount][2];
    for(int i=0; i<sourceCount; i++){
      sources[i] = new White();
      float phi = HALF_PI + i*0.8 - 0.4*(sourceCount-1);
      sourceKnobs[i][0] = (radius+1)*cos(phi);
      sourceKnobs[i][1] = (radius+1)*sin(phi);
      if(sourceCount==1)
        sourceDescriptions[i] = "Source";
      else
        sourceDescriptions[i] = "Source "+(char)('A' + sourceCount - i - 1);
    }
    selectedSources = new boolean[sourceCount];
    attributes = new Attribute[attributeCount];
    filters.add(this);
  }
  //---------------------
  void sourceDescription(int whichSource,String desc){
    sourceDescriptions[whichSource] = desc;
  }
  void sourceDescriptions(String a){ sourceDescriptions = new String[]{a}; }
  void sourceDescriptions(String a,String b){ sourceDescriptions = new String[]{a,b}; }
  void sourceDescriptions(String a,String b,String c){ sourceDescriptions = new String[]{a,b,c}; }
  //---------------------
  void delete(){ deleteMe = true; }
  //---------------------
  void drawNode(){
    noStroke();
    if(selected) fill(255,0,0,128); else fill(0,64);
    ellipse(x,y,2*radius,2*radius);
    if(sourceCount==0) line( x-radius+2, y, x+radius-2, y );
    fill(0);
    textAlign(CENTER);
    text(name,x+1,y+3);
    
  }
  //---------------------
  void drawConnections(){
    for(int i=0; i<sources.length; i++){
      TextureFilter s = sources[i];
      float d = dist(x,y,s.x,s.y);
      float nx = (s.x-x) / d;
      float ny = (s.y-y) / d;
      float ax = x + sourceKnobs[i][0];
      float ay = y + sourceKnobs[i][1];
      float bx = x + nx*(d-radius);
      float by = y + ny*(d-radius);
      
      strokeWeight(2);
      stroke(0);
      line(ax,ay,bx,by);
      
      if( dist((ax+bx)/2,(ay+by)/2,mouseX,mouseY) < handleRadius+2 ){
        stroke(255,192);
        strokeWeight(10);
        line((ax+bx)/2,(ay+by)/2,textWidth(sourceDescriptions[i])+3+(ax+bx)/2,(ay+by)/2);
        noStroke();
        fill(0);
        textAlign(LEFT);
        text( sourceDescriptions[i] ,7+(ax+bx)/2,3+(ay+by)/2);
      }
      
      strokeWeight(2);
      stroke(0);
      fill(255);
      ellipse((ax+bx)/2,(ay+by)/2,2*handleRadius,2*handleRadius);
      noStroke();
      fill(0);
      ellipse( ax,ay, 5,5 );
      ellipse( bx,by, 5,5 );
    }
  }
  //---------------------
  void updatePosition(){
    x += fx;
    y += fy;
    fx = fy = 0;
  }
  //---------------------
  void forces(){
    float gravity = 0.25;
    float step = 0.002;
    float optimalDist = 40;
    
    for(int i=0; i<sources.length; i++){
      TextureFilter s = sources[i];
      float d = dist(x,y,s.x,s.y);
      s.fx += step*(x-s.x)*(d-optimalDist);
      s.fy += step*(y-s.y)*(d-optimalDist) + gravity;
    }
  }
  //---------------------
  void mutualRepulsion(TextureFilter peer){
    if(peer!=this){
      float step = 0.001;
      float minDist = 40;
      float d = dist(x,y,peer.x,peer.y);
      if(d < minDist){
        fx -= step*(x-peer.x)*(d-minDist);
        fy -= step*(y-peer.y)*(d-minDist);
      }
    }
  }
  //---------------------
  //--Returnerar ett färgvärde för den specificerade punkten
  Color output( float x, float y , float z){
    return new Color(255,255,255);
  }
  //---------------------
  // there must be no loops in the node-graph
  boolean isChild(TextureFilter tf){
    if(tf==this) return true;
    
    for(int i=0; i<sources.length; i++)
      if( sources[i] == tf ) return true;
      
    for(int i=0; i<sources.length; i++)
      if( sources[i].isChild(tf) ) return true;
    
    return false;
  }
  //---------------------
  public void setSource( int sourceIndex, TextureFilter inSource){
    // there must be no loops in the node-graph
    if( !inSource.isChild(this) ){
      sources[sourceIndex] = inSource;
      refresh();
    }
  }
  //---------------------
  public void replaceSource( int sourceIndex, TextureFilter inSource){
    // there must be no loops in the node-graph
    if( !inSource.isChild(this) ){
      sources[sourceIndex].delete();
      sources[sourceIndex] = inSource;
      refresh();
    }
  }
  //---------------------
  //--Möjliggör redigering av filtrets ikon-position
  void setIconPos( int inX, int inY){
    x = inX;
    y = inY;
  }
  //---------------------
  boolean inside(int inX, int inY){
    return dist(x,y,inX,inY) < radius;
  }
  //---------------------
  void mouseDown(int inX, int inY){
    if( inside(inX,inY) )
      select();
    else
      deselect();
      
    for(int i=0; i<sources.length; i++){
      TextureFilter s = sources[i];
      float d = dist(x,y,s.x,s.y);
      float ax = x + sourceKnobs[i][0];
      float ay = y + sourceKnobs[i][1];
      float bx = x + (s.x-x)*(d-radius)/d;
      float by = y + (s.y-y)*(d-radius)/d;
      fill(255);
      if( dist((ax+bx)/2,(ay+by)/2,inX,inY) < handleRadius+2 ){
        connectionSelectedFilter = this;
        connectionSelectedSource = i;
      }
    }
  }
  //---------------------
  void keyPress(int inX, int inY, int sourceIndex){
    if( dist(x,y,inX,inY) < radius ){
      if(selectedFilter!=null){
        if(sourceIndex<selectedFilter.sourceCount){
          selectedFilter.setSource(sourceIndex,this);
        }
      }
    }
  }
  //---------------------
  void deselect(){
    if(selected && selectedFilter==this) selectedFilter = null;
    selected = false;
  }
  //---------------------
  void select(){
    selectedFilter = this;
    selected = true;
  }
  //---------------------
  String attributeDescription(){
    String desc = "";
    String[] prefices = new String[]{"Q,W: ","A,S: ","Z,X: "};
    for(int i=0; i<attributes.length; i++)
      if( i==0 )
        desc = prefices[i] + attributes[i].description();
      else
        desc = desc +", " + prefices[i] + attributes[i].description();
    
    return desc;
  }
  //---------------------
  String attributeDescription(int index){
    if(index<attributes.length)
      return attributes[index].description();
    else
      return "";
  }
  //---------------------
  void setAttribute(int index, String name, int type, float defaultValue, float step){
    if(index<attributes.length)  attributes[index] = new Attribute(name, type, defaultValue, step);
  }
  //---------------------
  float getAttribute(int index){
    if(index<attributes.length)
      return attributes[index].value;
    else
      return 0;
  }
  //---------------------
  void increaseAttribute(int index){
    if(index<attributes.length)  attributes[index].increase();
  }
  //---------------------
  void decreaseAttribute(int index){
    if(index<attributes.length)  attributes[index].decrease();
  }
}
//----------------------------------------------------------------
class Attribute{
  int type;
  String name;
  public float value;
  private float step;
  Attribute(String name, int type, float defaultValue, float step){
    this.name = name;
    this.value = defaultValue;
    this.type = type;
    this.step = step;
  }
  float value(){
    return value;
  }
  String description(){
    return name + ": " + format(value);
  }
  void increase(){
    if( type==LINEAR )
      value += step;
    else if( type==EXPONENTIAL )
      value *= step;
  }
  void decrease(){
    if( type==LINEAR )
      value -= step;
    else if( type==EXPONENTIAL )
      value /= step;
  }
}
//----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------