int w;
int h;
int w2;
int h2;
int npixels;
int npixels2;
int bg1=0xDDDDCC;
int bg2=0xDDCCCC;
color bg_col=color(221,221,204);
boolean update;
PImage blurImg;
float nLevels;
float resolution=3;
//color[] colors={color(220,220,203),color(100,150,120),color(222,122,172),color(222,33,65),color(145,22,42),color(145,91,80),color(32,96,128),color(204,153,51)};
color[] colors={color(173,226,191),color(246,211,221),color(246,57,103),color(225,38,67),color(55,166,203)};
//{0x915071,0xDEDEDE,0xDE2141,0xDE7AAC,0x91162A};
  //DED2CC - 915B50 - 206080 - CC9933
float offset;
float noiseVal;
Branch mainBranch;
float effectBlend=0;
int nextTime;
boolean inited;
boolean inited2;

color frame_col=color(222,33,65);// strong red
color border_col=color(220,220,203);// weak green

Vector blendedRects;
int[] leftPrintScreen;

PFont tooltipFont;
ToolTip toolTip;

boolean showPalette;
Palette palette;
boolean colorChanged;

void setup(){
  nLevels=0;
  offset=1;
  size(600,300,P3D);
  w=width;
  h=height;
  npixels=w*h;
  npixels2=int(npixels*.5);
  w2=int(w*.5);
  h2=int(h*.5);
  //background(221,204,204);
  int[] parentPixels=new int[npixels];
  for(int y=0; y<h; y++){
    for(int x=w2; x<w; x++){
      parentPixels[w*y+x]=1;
    }
  }
  // init Branch
  mainBranch=new Branch(int(w*.75),int(h*.25),color(221,204,204),parentPixels,new TreeRect(0,0,300,300),0);
  int[] pixels_1= new int[npixels];
  int[] pixels_2= new int[npixels];
  int pos;
  int x1=w2+int(w2*.75);
  int y1=int(h*.25);
  int x2=w2+int(w2*.25);
  int y2=int(h*.75);
  for(int y=0; y<h; y++){
    for(int x=w2; x<w; x++){
      pos=w*y+x;
      if(distance(x,y,x1,y1)<distance(x,y,x2,y2)){
        pixels_1[pos]=1;
      }
      else{
        pixels_2[pos]=1;
      }
    }
  }
  mainBranch.addBranch(x2,y2,color(195,206,200),pixels_2,new TreeRect(0,0,int(w2*.5),h));
  mainBranch.addBranch(x1,y1,color(221,204,204),pixels_1,new TreeRect(int(w2*.5),0,int(w2*.5),h));
  blurImg=new PImage(w2,h);
  blendedRects=new Vector();
  leftPrintScreen=new int[npixels2];
  tooltipFont = loadFont("V5Eastergothic-16.vlw"); 
  textFont(tooltipFont, 16);
  textMode(SCREEN);
  toolTip=new ToolTip();
  inited=false;
  inited2=false;
  showPalette=false;
  palette=new Palette();
  colorChanged=false;
}

void draw(){
  if(!inited){
    update=true;
    nextTime=millis();
    inited=true;
    effectBlend=1;
  };
  if(!inited2){
    if(mouseX!=pmouseX) inited2=true;
  }else{
    if(mouseX>=w2 && pmouseX<w2){
      effectBlend=1;
      update=true;
      nextTime=millis();
      inited=true;
    }else if(mouseX<w2){
      if(millis()>nextTime){
        effectBlend=mouseX/float(w2);
        nextTime=millis()+1000;
        update=true;
      }
    }
  }
  if(update){
    update=false;
    stroke(border_col);
    mainBranch.drawMe();
    loadPixels();
    blurImg.loadPixels();
    for(int y=0; y<h; y++){
      for(int x=w2; x<w; x++){
        leftPrintScreen[(w2*y)+(x-w2)]=pixels[(w*y)+(x-w2)];
        blurImg.pixels[(w2*y)+(x-w2)]=pixels[w*y+x];
      }
    }
    fastblur(blurImg,int(20*effectBlend));
  }else{
    loadPixels();
    for(int y=0; y<h; y++){
      for(int x=0; x<w2; x++){
        pixels[(w*y)+x]=leftPrintScreen[w2*y+x];
      }
    }
    updatePixels();
  }
  image(blurImg,w2,0);
  int col;
  loadPixels();
  for(int y=0; y<h; y++) {
    for(int x=w2; x<w; x++) {
      noiseVal=blue(pixels[(y*w)+x])/255;
      if(noiseVal>0){
        noiseVal+=offset;
        if(noiseVal>1) noiseVal--;
        col=colors[floor(noiseVal*colors.length*resolution)%(colors.length)];
        pixels[(w*y)+x]=col;
      }/*else{
         pixels[(w*y)+x]= pixels[(w*y)+(w-1-x)]=bgcolor;
      }*/
    }
  }
  updatePixels();
  int len=blendedRects.size();
  if(len>0){
    TreeRect tr;
    stroke(border_col);
    for(int i=0; i<len; i++){
      tr=(TreeRect) blendedRects.get(i);
      fill(255,tr._blend);
      rect(tr._x,tr._y,tr._w,tr._h);
      tr.update();
      if(tr._blend<=0){
        blendedRects.remove(i);
        i--;
        len--;
      }
    }
  }
  if(mouseX<w2 && !showPalette && inited2/* && (mouseX!=pmouseX || mouseY!=pmouseY)*/){
    fill(255);
    rect(0,0,w2,h);
    stroke(border_col);
    mainBranch.highLightBranch(mouseX,mouseY);
    if(mouseX!=pmouseX || mouseY!=pmouseY){
      Branch rollBranch=mainBranch.getRect(mouseX,mouseY);
      if(rollBranch != null){
        TreeRect tr=rollBranch.leftRect;
        toolTip.updateContent(rollBranch._level,(tr._w*tr._h*100.0)/npixels2);
        
        /*stroke(border_col);
        fill(255);
        rect(tr._x,tr._y,tr._w,tr._h);*/
      }
    }
  }
  offset-=0.001;
  if(offset<0) offset++;
  // borders
  stroke(frame_col);
  line(0,0,w,0);
  line(w-1,0,w-1,h);
  line(w,h-1,0,h-1);
  line(0,h,0,0);
  line(w2-1,0,w2-1,h);
  line(w2,0,w2,h);
  if(mouseX<w2 && !showPalette){
    toolTip.updateMe();
    toolTip.drawMe();
  }
  if(keyPressed) { 
    if (key == 'c' || key == 'C') {
      showPalette=true;
      palette.drawMe();
    }else{
      showPalette=false;
    }
  }else{
    showPalette=false;
  }
}

void mousePressed() {
  println("showPalette");
  if(showPalette){
    palette.checkPalette();
    return;
  }
  if(mouseX<w2) return;
  Branch parent=mainBranch.getBranch(mouseX,mouseY);
  parent.splitMe(mouseX,mouseY,darkCol(parent._col));
  update=true;
}
color darkCol(color c){
  int gshift = 255<<8;
  int rshift = 255<<16;

  float r=(c & rshift) >> 16;
  float g=(c & gshift) >> 8;
  float b=c & 255;

  if(g>r){
    //from green
    r+=(100-r)*.1;
    g+=(150-g)*.1;
    b+=(120-b)*.1;
  }
  else{
    //from red
    r+=(181-r)*.1;
    g+=(16-g)*.1;
    b+=(16-b)*.1;
  }
  return color(int(r),int(g),int(b));
}
float distance(int x1, int y1, int x2, int y2){
  return sqrt(sq(x1-x2)+sq(y1-y2));
}
// ==================================================
// Super Fast Blur v1.1
// by Mario Klingemann <http://incubator.quasimondo.com>
// Christian Giordano just removed the blue and red channel
// ==================================================
void fastblur(PImage img,int radius){

  if (radius<1){
    return;
  }
  int w=img.width;
  int h=img.height;
  int wm=w-1;
  int hm=h-1;
  int wh=w*h;
  int div=radius+radius+1;
  int b[]=new int[wh];
  int bsum,x,y,i,p,p1,p2,yp,yi,yw;
  int vmin[] = new int[max(w,h)];
  int vmax[] = new int[max(w,h)];
  int[] pix=img.pixels;
  int dv[]=new int[256*div];
  for (i=0;i<256*div;i++){
    dv[i]=(i/div);
  }

  yw=yi=0;

  for (y=0;y<h;y++){
    bsum=0;
    for(i=-radius;i<=radius;i++){
      p=pix[yi+min(wm,max(i,0))];
      bsum+= p & 0x0000ff;
    }
    for (x=0;x<w;x++){

      b[yi]=dv[bsum];

      if(y==0){
        vmin[x]=min(x+radius+1,wm);
        vmax[x]=max(x-radius,0);
      }
      p1=pix[yw+vmin[x]];
      p2=pix[yw+vmax[x]];

      bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
      yi++;
    }
    yw+=w;
  }

  for (x=0;x<w;x++){
    bsum=0;
    yp=-radius*w;
    for(i=-radius;i<=radius;i++){
      yi=max(0,yp)+x;
      bsum+=b[yi];
      yp+=w;
    }
    yi=x;
    for (y=0;y<h;y++){
      //pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
      pix[yi]=0xff000000 | dv[bsum];
      if(x==0){
        vmin[y]=min(y+radius+1,hm)*w;
        vmax[y]=max(y-radius,0)*w;
      }
      p1=x+vmin[y];
      p2=x+vmax[y];

      bsum+=b[p1]-b[p2];

      yi+=w;
    }
  }

}