root/InOutExpositor/Utils.pde

////////////////////////////////////////////////////////////////
// Various / useful
////////////////////////////////////////////////////////////////
String rCharriots(String inStr) {
  String res = "" ;
  int maxLine = 32 ;
  int strLen = inStr.length() ;
  if(strLen>maxLine) {
    int i = 0 ;
    int ptt = strLen ;
    res = inStr.substring(0,maxLine) ;
    while(ptt>maxLine) {
      i++ ;
      int lastPos = (i+1)*maxLine ;
      if(lastPos>strLen) lastPos = strLen ;
      res += "...\n   ..."+inStr.substring(i*maxLine, lastPos) ;
      ptt = strLen - lastPos ;
      if(i>2) {
        res +=  " (...)" ;
        ptt = 0 ; 
      }
    }
  }
  else res = inStr ;
  return res ;
}
////////////////////////////////////////////////////////////////
String getTypeString(int t) {
  String res = "" ;
  if(t==0) return res = "data" ;
  if(t==1) return res = "audio" ;
  if(t==2) return res = "video" ; 
  return res ;
}

String getTimeStamp() {
  Date D = new Date() ;
  long tt = D.getTime() ;
  long ttt = tt/(long)1000 ;
  String res = String.valueOf(ttt) ;
  return res ;
}
String formatTimeStamp(long tmpstmp) {
   Date thedate = new Date((long)tmpstmp*1000);
  DateFormat formatter = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
  String dateStr = formatter.format(thedate);
 return dateStr;
}
//////////////////////////////////////////////////////////////////////
void addTagInVector( Vector vect, String inMot, int inVal ) {
  boolean dejaLa = false ;
  Tag mt ;
  for(int i=0;i<vect.size();i++) {
    mt = ((Tag)vect.elementAt(i)) ;
    if( mt.tag.equals(inMot) ) {
      mt.val = mt.val+inVal ;
      dejaLa = true ;
    }
  }
  if(!dejaLa) vect.add( new Tag(inMot,inVal) ) ;
}
/// TAGS ///////////////////////////////////////////////////////////////////////////
Vector makeTagsFromString( String inStr ) /////// get {A B C} TAG Vector from "A.12/B.13/C.QS..." string
{
  Vector res = new Vector() ;
  String[] ls = split(inStr,aVirg) ;
  for(int i=0;i<ls.length;i++) {
    res.addElement( new Tag(ls[i], 0) ) ;
  }
  return res ;
}
String makeStringFromTags( Vector vect ) // get String from Tags Vector
{
  String stri="" ;
  for(int u=0;u<vect.size();u++) {
    stri += ((Tag)vect.elementAt(u)).getString() ;
    if(u!=vect.size()-1) stri += aVirg ; 
  }
  return stri ;
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
Client getSelected()
{
  if(selected!=null) return selected ; 
  else return getClient(0) ;
}
//////////////////////////////////////////////////////////////////
Client getClient( int id ) { // return Client associated with id
  return (Client)myClients.elementAt(id) ;
}
//////////////////////////////////////////////////////////////////
int getIdOfLogin( String login ) { // return the id of login (-1 if doesnt exist)
  int res = -1 ;
  for(int i=0;i<nClients;i++) {
    String loginHad = ((Client)myClients.elementAt(i)).login ;
    if(loginHad.equals(login))
      res = i ;
  }
  return res ;
}
//////////////////////////////////////////////////////////////////
Vector getOutLinkedClients( Client A )
{
  Vector res = new Vector() ;
  for(int i=0;i<nClients;i++) {
    if( drawnState.isAnyLink(A.id,i) )
      res.add(getClient(i)) ;
  }
  return res ;
}
Vector getInLinkedClients( Client A )
{
  Vector res = new Vector() ;
  for(int i=0;i<nClients;i++) {
    if( drawnState.isAnyLink(i,A.id) )
      res.add(getClient(i)) ;
  }
  return res ;
}
Vector getOutLinkedClients( Client A, int type )
{
  Vector res = new Vector() ;
  for(int i=0;i<nClients;i++) {
    if( drawnState.isLink(type,A.id,i) )
      res.add(getClient(i)) ;
  }
  return res ;
}
Vector getInLinkedClients( Client A, int type )
{
  Vector res = new Vector() ;
  for(int i=0;i<nClients;i++) {
    if( drawnState.isLink(type,i,A.id) )
      res.add(getClient(i)) ;
  }
  return res ;
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
int randomButMe(int id)
{
  int a = int(random(0,nClients)) ;
  if(nClients>1) {
    while(a==id)
      a = int(random(0,nClients)) ;
  }
  else a = 0 ;
  return a ;
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
int getNombreConnex( int i, State inState, int type, boolean isOut ) // retourne le nombre reel de connexion d'une cellule
{
  int res = 0 ;
  if(isOut) {
    for(int j=0;j<nClients;j++) {
      if( inState.isLink(type,i,j) ) res+=1 ; // i ---> j
    }
  }
  else {
    for(int j=0;j<nClients;j++) {
      if( inState.isLink(type,j,i) ) res+=1 ; // j ---> i
    }  
  }
  return res ; 
}
//////////////////////////////////////////////////////////////////
boolean isLinkPossible(int type, int i, int j) // i ----> j
{
  boolean res = true ;

  if( !getClient(i).isLinkOn(type,true) ) res = false ;
  if( !getClient(j).isLinkOn(type,false) ) res = false ;
  if( !(getClient(i).connected && getClient(j).connected) ) res = false ;

  return res ;
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
float getLinkAngle( Client A, Client B ) // A -------> B
{
  float x1 = A.x() ;
  float y1 = A.y() ;
  float x2 = B.x() ;
  float y2 = B.y() ;

  return (float)getPointsAngle(x1,y1,x2,y2) ;
}
float getPointsAngle(float x1, float y1, float x2, float y2) {
  float ang = PI/2 ;
  if(x2!=x1) ang = atan( (y2-y1)/(x2-x1) ) ;
  if(x2<x1) ang = ang + PI ;

  float res = modAngle(ang) ;
  return res ;
}
//////////////////////////////////////////////////////////////////
void reajustLinkedAngles( Client A, Client B ) // A -------> B
{
  A.angle = adjustToAngle(A.angle, getLinkAngle(A,B)) ;
  B.angle = adjustToAngle(B.angle, getLinkAngle(A,B)) ;
}
float adjustToAngle(float a, float to)
{
  if(to<a) to=to+2*PI ;
  float pDiff = to-a ;
  float minDiff = min(pDiff, 2*PI-pDiff) ;
  float newdA = minDiff/20 ; 
  if(pDiff<PI) a+= newdA ;
  else a-= newdA ;
  return  modAngle(a) ;
}
float modAngle( float a )
{
  return a%(2*PI) ;
}
void refreshLinkedAngles()
{
  Client c,l ;
  for(int i=0;i<nClients;i++) {
    c = getClient(i) ;
    Vector outL = getOutLinkedClients(c) ;
    for(int j=0;j<outL.size();j++) {
      l = (Client)outL.elementAt(j) ;
      l.angle = adjustToAngle( l.angle, getLinkAngle(l,c) ) ;
      c.angle = adjustToAngle( c.angle, getLinkAngle(l,c) ) ;
    }
  }
}
//////////////////////////
void setTypeColors() {
  dColor = color(random(20,255),random(20,255),random(20,255));
  aColor = color(random(20,255),random(20,255),random(20,255));
  vColor = color(random(20,255),random(20,255),random(20,255));
}
color getColorType(int type) {
  color res = color(200,200,200) ;
  if(type==0) res = dColor ;
  if(type==1) res = aColor ;
  if(type==2) res = vColor ;
  return res ;
}
//////////////////////////
int getMaxNameLength() {
  int res = 0 ;
  for(int i=0;i<nClients;i++) {
    String nam = getClient(i).name ;
    if(nam.length()>res) res = nam.length() ;
  }
  return res ;
}
//////////////////////////
float distance(Client A, Client B) {
  float res = sqrt(pow(A.x()-B.x(),2)+pow(A.y()-B.y(),2)) ;
  return res ; 
}