root/InOutExpositor/oClient.pde

/////////////////////////////////////////////////////////////////////////////////////
// See the InOutServer comments for more informations on the Client class
/////////////////////////////////////////////////////////////////////////////////////
class Client {
  //////////////
  int id ;
  //////////////// ALIVE
  boolean connected ;
  boolean goingToDisconnect ;
  //////////////// CONNEXION
  String login ;
  String ip ;
  String Vip, Aip ; // Streams
  ////////////// DATE
  String lastDate, firstDate ;
  ////////////// PROJECT
  String name,author,descr,location ;
  float sReachability, sActivity, sSociability, sWeight ;
  /////////////////// IN/OUT Profile
  Aspiration[] in ;
  Determinant[] out ;
  ///////////////////
  float pw = 80 ;
  float ph = 60 ;
  /////////////////// PREVIEWS / PNGs
  boolean showPreview = false ;
  boolean showSmallPreview = false ;
  Pnger thePNGs ; // for .png previews
  //////////////// PHYSICS / SPRINGS
  Particle p ;
  Particle c ;
  Spring anchorLink ;
  Vector springLinks ; // between Clients
  Vector tagSprings ; // between Tags
  Vector repulsionLinks ;
  //////////////// TENTACULES
  Vector tentacules ;
  //////////////// POSITION / ANGLE
  float angle ; // between 0 and 2*PI
  float nx, ny, t, ang, nang, r, nr ;
  //////////////// THINGS
  Explorator Exp ;
  boolean roundImageDone = false ;

  //////////////// For the parcours ellipse view
  boolean toBeCloned = false ;

  int rollPreviewType = 0 ;
  float selZone = 12 ;

  Client( int _id, String _login, String _name, String _descr, Aspiration[] inA, Determinant[] outD ) { // Creation of USER
    id = _id ;
    login = _login ;
    name = _name ;
    descr = _descr ;
    goingToDisconnect = false ;
    connected = true ;

    ip="-";
    Vip="-";
    Aip="-";

    firstDate = lastDate = getTimeStamp() ;

    in = new Aspiration[3] ;
    out = new Determinant[3] ;
    in = inA ;
    out = outD;

    buildPositionAndParticle() ;
    buildExplorator(0,0) ;

    thePNGs = new Pnger(id,login) ;
  }
  void buildPositionAndParticle() {
    ////////// Position
    float _x,_y ;
    float bor = 200 ;
    _x = random(bor,width-bor) ;
    _y = random(upControlZone+bor, height-bor) ;
    //_x = width/2 ;
    //_y = centerY ;

    ////////// Particle
    p = physics.makeParticle( 1.0, _x, _y, 0 );
    c = physics.makeParticle( 1.0, _x, _y, 0 ); // link with the initial position (on a cicle)
    c.makeFixed() ;
    anchorLink = physics.makeSpring( p, c, 0.1, 0.1, 2 ); 
    springLinks = new Vector() ;
    repulsionLinks = new Vector() ;
    angle = random(-PI,PI) ;

    ////////// Tentacules (in et out dispos)
    tentacules=new Vector() ;
    for(int u=0;u<6;u++) {
      TentacSimple tend = new TentacSimple(p,u) ;
      tentacules.addElement(tend) ;
    }
  }
  ////////////////////////////////
  void buildExplorator( int idepth, int odepth ) {
    Exp = new Explorator( this, idepth, odepth ) ;
  }
  void traceExplorator() {
    Exp.trace(false) ; // IN
    Exp.trace(true) ; // OUT
  }
  ////////////////////////////////////////////////////////////
  void setIP( String newIp ) {
    if(newIp.charAt(0)=='/') {
      String[] ipTab = split(newIp,"/") ;
      ip = ipTab[1] ;
    }
    else ip = newIp ;

    connected = !ip.equals("Offline") ;
  }
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  void traceTentacules() {
    boolean show=false ;
    for(int i=0;i<6;i++) {
      if(i<=2) show=in[i].on ;
      else show=out[i-3].on ;
      if(show) ((TentacSimple)tentacules.elementAt(i)).trace() ;
    }
  }
  void traceOutLinks() {
    if(showType[0]) traceOutLinks(0) ;
    if(showType[1]) traceOutLinks(1) ;
    if(showType[2]) traceOutLinks(2) ;
  }
  void traceOutLinks( int type ) {
    Vector outCopins = getOutLinkedClients(this,type) ;
    Client copin ;
    for(int i=0;i<outCopins.size();i++) {
      copin = (Client)outCopins.elementAt(i) ;
      if(showLinkArcs)        drawArcLink(copin,this,false,type) ;
      if(showLinkCurves)      drawArcLink(copin,this, true,type) ;
      if(showLinkDirect)      drawOrientedDottedLine(this, copin,type) ;
      if(showLinkSimple)      drawOrientedSimpleLine(this,copin,type) ;
      if(showLinkHalfCircles) drawHalfCircle( this, copin, hwcYPos, type ) ;
    }
  }
  void traceClientCloneAt(float x, float y, float op) {
    noStroke() ;
    fill(255,op) ;
    ellipse( x, y, 7, 7 );
    if(!onlyRolloverText || (highlighted==this || selected==this)) {
      String clientInfos = getInfosString() ;
      textFont(font,10);
      text(this.name,x+10,y+17) ;
    }
  }
  void traceClientWeight() {
    if(connected) {
      stroke(190,140,140) ;
      fill(190,140,140,100) ;
    }
    else {
      stroke(190,140,140) ;
      fill(190,140,140,30) ;
    }
    float ss = 30+sWeight*90 ;
    ellipse( x(), y(), ss, ss );
  }
  void traceClientPoint() {
    noStroke() ;
    if(connected) fill(255) ;
    else fill(200,150) ;
    float ss = 8 ;
    if(!connected) ss = 5 ;
    ellipse( x(), y(), ss, ss );
  }
  void traceClient() {
    if(t!=-1) goingToNewPos() ;

    if(showStatsBackg) traceClientWeight() ;

    if(showTentacules) traceTentacules() ;

    if(springsToAnchor) traceLinkToAnchor() ;

    if(isInside(mouseX,mouseY) && !mousePressed) highlighted = this ;

    if(highlighted==this || selected==this) {
      noFill() ;
      stroke(240) ;
      ellipse( x(), y(), 14, 14 );
    }
    if(showClientBox) {
      int col = 220 ;
      if(!connected) col = 100 ;
      stroke(col) ;
      fill(col,150) ;
      traceBox(x(),y()) ;
    }

    traceClientPoint() ;

    if(!onlyRolloverText || (highlighted==this || selected==this)) {
      String clientInfos = getInfosString() ;
      textFont(font,10);
      text(clientInfos,x()+10,y()+17) ;
    }
  }
  ////////////////////////////////////////////////////////////
  void setTo(float _x, float _y) {
    c.moveTo(_x,_y,0) ;
    p.moveTo(_x,_y,0) ;
    t=-1 ;
  }
  void setPositionTo(float _x, float _y) {
    c.moveTo(_x,_y,0) ;
    p.moveTo(_x,_y,0) ;
  }
  void moveTo(float _x, float _y) {
    t=0 ;
    nx=_x ;
    ny=_y ;
    nang=atan2((ny-centerY),(nx-width/2)) ;
    nr=dist(width/2,centerY,nx,ny) ;
  }
  void setFixedAnchorPosition(float _x, float _y) {
    //moveTo(_x,_y) ;
    //float ecar = 100 ;
    //p.moveTo(_x,_y,0) ;
    //p.moveTo(_x+random(-ecar,ecar),_y+random(-ecar,ecar),0) ;
  }
  ////////////////////////////////////////////////////////////
  void goingToNewPos() {
    if (radialClientsMovement) goingToNewPosRadial() ;
    else goingToNewPosLinear() ;
  }
  void goingToNewPosLinear() {
    t++ ;
    float cx = lerp(nx,x(),clientsSpeedFactor+0.05/(t+1)) ;
    float cy = lerp(ny,y(),clientsSpeedFactor+0.05/(t+1)) ;
    setPositionTo(cx,cy) ;
    if(abs(nx-x())<1 && abs(ny-y())<1) { 
      t=-1 ;
      setPositionTo(nx,ny) ;
    }
  }
  void goingToNewPosRadial() {
    t++ ;
    ang=lerp(nang,ang,clientsSpeedFactor) ;
    r=lerp(nr,r,clientsSpeedFactor) ;
    setPositionTo( width/2+r*cos(ang), centerY+r*sin(ang) ) ;
    if(abs(nx-x())<1 && abs(ny-y())<1) { 
      t=-1 ;
      setPositionTo(nx,ny) ;
    }
  }
  ////////////////////////////////////////////////////////////
  void tracePreviewPNG( float sss ) {
    float dmargin = 5 ;
    float dscale = sss;
    float decy = 40 ;
    float u = 10 ;
    float wid = dscale*320 ;
    noStroke() ;
    fill(150,100) ;
    pushMatrix() ;
    triangle(x(),y(),x()-u,y()+decy, x()+u, y()+decy) ;
    translate(x()-wid/2,y()+decy) ;
    rect(0,0,wid+2*dmargin,dscale*240+2*dmargin) ;
    try {
      thePNGs.traceImage(dmargin,dmargin,wid,dscale*240) ;
    }
    catch(Exception e) {
      print("Image Preview Problem : "+e+"\n") ; 
    }
    popMatrix() ;
  }
  int getRolloverPreviewType() {
    int res = -1 ;
    float lx = mouseX-x()-5 ;
    float ly = mouseY-y()-5 ;
    if(lx>0 && lx<pw ) {
      if(ly>0 && ly<contextH) {
        int tt = 0 ;
        if(out[0].on ) {
          if(ly>tt*ph && ly<(tt+1)*ph) res = 0 ;
          tt++ ;
        }
        if(out[1].on ) {
          if(ly>tt*ph && ly<(tt+1)*ph) res = 1 ;
          tt++ ;
        }
        if(out[2].on ) {
          if(ly>tt*ph && ly<(tt+1)*ph) res = 2 ;
          tt++ ;
        }
      }
    }
    return res ;
  }
  /////////////////////////////////////////////////////////////////////////////////////
  void traceLinkToAnchor() {
    stroke(120,40,90,80) ;
    fill(120,40,90,80) ;
    line(x(),y(),c.position().x(),c.position().y());
    noStroke() ;
    ellipse(c.position().x(),c.position().y(),6,6);
  }
  //////////////////////////////////////////////////////////////////////////////
  void traceBox( float _x, float _y) {
    pushMatrix() ;
    translate(_x,_y) ;
    rotate(angle) ;
    //traceRoundPreview( 0, 0 ) ;
    rectMode(CENTER) ;
    //rect(0,0,clientBoxL,clientBoxH) ;
    ellipse(0,0,clientBoxL,clientBoxH) ;
    //line(0,0,30,0) ;
    popMatrix() ;
    rectMode(CORNER) ;
  }
  String getInfosString() {
    String res = login ;
    if(showClientName) {
      res += " ("+ip+")\n";
      res += "Project : "+name +"\n" ;
      res += "Description : "+rCharriots(descr) + "\n";
      if(out[0].on && showType[0]) res += "\nD : "+out[0].getLisibleTagString() ;
      if(out[1].on && showType[1]) res += "\nA : "+out[1].getLisibleTagString() ;
      if(out[2].on && showType[2]) res += "\nV : "+out[2].getLisibleTagString() ;
      res += "\n" ;
    }
    else res += "\n" ;
    if(showClientInfo) {
      if(in[0].on && showType[0]) res += "\ninD: "+rCharriots(in[0].getString()) ;
      if(in[1].on && showType[1]) res += "\ninA: "+rCharriots(in[1].getString()) ;
      if(in[2].on && showType[2]) res += "\ninV: "+rCharriots(in[2].getString()) ;
      if(out[0].on && showType[0]) res += "\noutD: "+rCharriots(out[0].getString())  ;
      if(out[1].on && showType[1]) res += "\noutA: "+rCharriots(out[1].getString())  ;
      if(out[2].on && showType[2]) res += "\noutV: "+rCharriots(out[2].getString()) ;
      res += "\n" ;
    }
    if(showClientScore)  {
      if(in[0].on && showType[0]) res += "\nListD: "+rCharriots(getPreferedListString(this,0)) ;
      if(in[1].on && showType[1]) res += "\nListA: "+rCharriots(getPreferedListString(this,1)) ;
      if(in[2].on && showType[2]) res += "\nListV: "+rCharriots(getPreferedListString(this,2)) ;
      res += "\n" ;
    }
    return res ;
  }
  ////////////////////////////////////////////////////////////////////////////
  boolean hasFlux(int type, boolean isOut)
  {
    boolean res = true ;
    if( isOut && !out[type].on ) res = false ;
    if( !isOut && !in[type].on ) res = false ; 
    return res ;
  }
  ////////////////////////////////////////////////////////////////////////////
  void setClientSprings( boolean flag ) {
    if(flag) {
      springLinks = new Vector() ;
      Vector copins = getOutLinkedClients( this ) ;
      for(int i=0;i<copins.size();i++) {
        Client copin = (Client)copins.elementAt(i);
        //Spring makeSpring( Particle a, Particle b, float strength, float damping, float restLength )
        springLinks.addElement( physics.makeSpring( p, copin.p, 0.01, 0.2, 110 ) ) ;
      }
    }
    else {
      if( springLinks.size()!=0 ) {
        for(int i=0;i<springLinks.size();i++) {
          ((Spring)springLinks.elementAt(i)).turnOff() ;
        }
      }
    }
  }
  void setOtherRepulsions( boolean flag ) {
    if(flag) {
      repulsionLinks = new Vector() ;
      for(int i=0;i<nClients;i++) {
        Client copin = getClient(i) ;
        //Attraction makeAttraction( Particle a, Particle b, float strength, float minimumDistance )
        if(i!=id) repulsionLinks.addElement( physics.makeAttraction( p, copin.p, -10, 2 ) ) ;
      }
    }
    else {
      if( repulsionLinks.size()!=0 ) {
        for(int i=0;i<repulsionLinks.size();i++) {
          ((Attraction)repulsionLinks.elementAt(i)).turnOff() ;
        }
      }
    }
  }
  void linkToAnchor( boolean flag) {
    if(flag) anchorLink.turnOn() ;
    else anchorLink.turnOff() ;
  }
  //////////////////////////////////////////////
  float x() {
    return p.position().x() ;
  }
  float y() {
    return p.position().y() ;
  }
  ////////////////////////////////////////////////////////////
  boolean isLinkOn( int type, boolean isOut )
  {
    boolean res = false ;
    if(isOut) res = out[type].on ;
    else res = in[type].on ;
    return res ;
  }
  ////////////////////////////////////////////////////////////
  boolean isInside(float _x, float _y) {
    float d = dist(_x,_y,x(),y()) ;
    if(d<selZone) return true ;
    else return false ;
  }
  boolean isInContextual(float _x, float _y) {
    boolean res = false ;
    if(_x>x() &&_y>y() && _x<x()+contextW && _y<y()+contextH)
      res = true ;
    return res ;
  }
  ////////////////////////////////////////////////////////////
  // !! To do : verify it is a real .ogg stream and not another thing !!
  void setOutAudioStream( String newS ) {
    Aip = newS ;
  }
  void setOutVideoStream( String newS ) {
    Vip = newS ;
  }
}
//////////////////////////////////////////////////////////////////