/* -*-mode:java; c-basic-offset:2; -*- */
/* WeirdX - Guess.
 *
 * Copyright (C) 1999-2004 JCraft, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package com.jcraft.weirdx;
import java.io.*;

final class GC extends Resource {
  static final byte GXclear=0;
  static final byte GXand=1;
  static final byte GXandReverse=2;
  static final byte GXcopy=3;
  static final byte GXandInverted=4;
  static final byte GXnoop=5;
  static final byte GXxor=6;
  static final byte GXor=7;
  static final byte GXnor=8;
  static final byte GXequiv=9;
  static final byte GXinvert=10;
  static final byte GXorReverse=11;
  static final byte GXcopyInverted=12;
  static final byte GXorInverted=13;
  static final byte GXnand=14;
  static final byte GXset=15;

  static final int lineStyleOffset=0;
  static final int lineStyle=(3<<lineStyleOffset);
//  private byte lineStyle=LineSolid;
  static final int LineSolid=(0<<lineStyleOffset);
  static final int LineOnOffDash=(1<<lineStyleOffset);
  static final int LineDoubleDash=(2<<lineStyleOffset);

  static final int capStyleOffset=2;
  static final int capStyle=(3<<capStyleOffset);
  //private byte cap_style=CapButt;
  static final int CapNotLast=(0<<capStyleOffset);
  static final int CapButt=(1<<capStyleOffset);
  static final int CapRound=(2<<capStyleOffset);
  static final int CapProjecting=(3<<capStyleOffset);

  static final int joinStyleOffset=4;
  static final int joinStyle=(3<<joinStyleOffset);
  //private byte join_style=JoinMiter;
  static final int JoinMiter=(0<<joinStyleOffset);
  static final int JoinRound=(1<<joinStyleOffset);
  static final int JoinBevel=(2<<joinStyleOffset);

  static final int fillStyleOffset=6;
  static final int fillStyle=(3<<fillStyleOffset);

  //private byte fill_style=FillSolid;
  static final int FillSolid=(0<<fillStyleOffset);
  static final int FillTiled=(1<<fillStyleOffset);
  static final int FillStippled=(2<<fillStyleOffset);
  static final int FillOpaqueStippled=(3<<fillStyleOffset);

  static final int fillRuleOffset=8;
  static final int fillRule=(1<<fillRuleOffset);
//  private byte fill_rule=EvenOddRule;
  static final int EvenOddRule=(0<<fillRuleOffset);
  static final int WindingRule=(1<<fillRuleOffset);

  static final int arcModeOffset=9;
  static final int arcMode=(1<<arcModeOffset);
  //private byte arc_mode;
  static final int ArcChord=(0<<arcModeOffset);
  static final int ArcPieSlice=(1<<arcModeOffset);

  static final int subWindowModeOffset=10;
  static final int subWindowMode=(1<<subWindowModeOffset);
  static final int ClipByChildren=(0<<subWindowModeOffset);
  static final int IncludeInferiors=(1<<subWindowModeOffset);

  static final int graphicsExposuresOffset=11;
  static final int graphicsExposures=(1<<graphicsExposuresOffset);
  static final int tileIsPixelOffset=15;
  static final int tileIsPixel=(1<<tileIsPixelOffset);

  static final int GCFunction           =(1<<0);
  static final int GCPlaneMask          =(1<<1);
  static final int GCForeground         =(1<<2);
  static final int GCBackground         =(1<<3);
  static final int GCLineWidth          =(1<<4);
  static final int GCLineStyle          =(1<<5);
  static final int GCCapStyle           =(1<<6);
  static final int GCJoinStyle		=(1<<7);
  static final int GCFillStyle		=(1<<8);
  static final int GCFillRule		=(1<<9);
  static final int GCTile		=(1<<10);
  static final int GCStipple		=(1<<11);
  static final int GCTileStipXOrigin	=(1<<12);
  static final int GCTileStipYOrigin	=(1<<13);
  static final int GCFont 		=(1<<14);
  static final int GCSubwindowMode	=(1<<15);
  static final int GCGraphicsExposures  =(1<<16);
  static final int GCClipXOrigin	=(1<<17);
  static final int GCClipYOrigin	=(1<<18);
  static final int GCClipMask		=(1<<19);
  static final int GCDashOffset		=(1<<20);
  static final int GCDashList		=(1<<21);
  static final int GCArcMode		=(1<<22);

  static final int CT_NONE              =0;
  static final int CT_PIXMAP            =1;
  static final int CT_REGION            =2;
  static final int CT_UNSORTED          =6;        
  static final int CT_YSORTED           =10;
  static final int CT_YXSORTED          =14;
  static final int CT_YXBANDED          =18;

  Drawable drawable;
  Font font;
  short lineWidth;
  byte function;
  float dash[];
  float dash_phase;
  int attr;
  int time;
  Pix tile;
  Pixmap stipple;
  short tile_stipple_x_origin;
  short tile_stipple_y_origin;
  int clip_x_origin;
  int clip_y_origin;
  Clip clip_mask;
  int fgPixel, bgPixel;

  GC(int id, Drawable dr) {
    super(id, RT_GC);
    this.drawable=dr;
    init();
  }

  private void init(){
    font=Font.dflt;
    lineWidth=1 /*0*/;
    function=GXcopy;
    dash=null;
    dash_phase=0.0f;

    attr=( LineSolid|CapButt|JoinMiter|FillSolid|EvenOddRule
	  |ArcPieSlice|ClipByChildren|graphicsExposures);

    time=0;
    tile=new Pix();
    stipple=null;
    tile_stipple_x_origin=0;
    tile_stipple_y_origin=0;
    clip_x_origin=0;
    clip_y_origin=0;
    clip_mask=null;
    fgPixel=0;
    bgPixel=1;
  }

  static void reqSetDashes(Client c) throws IOException{
    int foo, ordering;
    int n;
    IO io=c.client;
    n=c.length;
    foo=io.readInt();

    c.length-=2;
    GC gc=c.lookupGC(foo);
    if(gc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }

    foo=io.readShort();
    gc.dash_phase=(float)foo;
    foo=io.readShort();
    if(foo==0){
      gc.dash=null;
      return;
    }

    gc.dash=new float[foo];

    n-=3;
    n*=4;
    for(int i=0; i<foo; i++){
      gc.dash[i]=(float)io.readByte();
      n--;
    }
    if(n>0){
      io.readPad(n);
    }
    gc.time=0;
  }

  static void reqSetClipRectangles(Client c) throws IOException{
    int foo, ordering;
    int n;
    IO io=c.client;

    ordering=c.data;
    n=c.length;
    foo=io.readInt();
    c.length-=2;
    GC gc=c.lookupGC(foo);
    if(gc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }
    gc.clip_x_origin=io.readShort();
    gc.clip_y_origin=io.readShort();
    c.length--;

    short x, y;
    int w, h;

    n=n-3;

    ClipRectangles cr=null;
    if(gc.clip_mask!=null){
      if(gc.clip_mask instanceof ClipPixmap){
        try{((Pixmap)(gc.clip_mask.getMask())).delete();}
        catch(Exception e){}
        gc.clip_mask=null;
      }	
    }

    if(cr==null){
      cr=new ClipRectangles(ordering, n/2);
      gc.clip_mask=cr;
    }

    while(n!=0){
      x=(short)io.readShort(); 
      y=(short)io.readShort();
      w=io.readShort(); 
      h=io.readShort();

      n-=2;
      cr.add(x, y, w, h);
    }

    cr.validate();
    c.length=0;
  }

  static void reqFreeGC(Client c) throws IOException{
    int foo;
    IO io=c.client;

    foo=io.readInt();

    c.length-=2;

    GC gc=c.lookupGC(foo);
    if(gc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }
    Resource.freeResource(foo, Resource.RT_NONE);
  }
  void delete() throws IOException{
    dash=null;
    if(stipple!=null){
      try{stipple.delete();}catch(Exception e){}
      stipple=null;
    }
    if(clip_mask!=null){
      try{
	if(clip_mask instanceof ClipPixmap){
	  ((Pixmap)(clip_mask.getMask())).delete();
	}
      }catch(Exception e){}
      clip_mask=null;
    }
    if(tile.pixmap!=null){
      try{tile.pixmap.delete();}catch(Exception e){}
      tile.pixmap=null;
      tile=null;
    }
    put(this);
  }
  static void reqCopyGC(Client c) throws IOException{
    int foo;
    IO io=c.client;
    foo=io.readInt();
    c.length-=2;
    GC srcgc=c.lookupGC(foo);
    if(srcgc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }
    foo=io.readInt();
    c.length--;
    GC dstgc=c.lookupGC(foo);
    if(dstgc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }
    int msk=io.readInt();
    c.length--;
    msk&=0x7fffff;
    dstgc.copyAttr(c, msk, srcgc);
  }
  static void reqChangeGC(Client c) throws IOException{
    int foo;
    int n;
    IO io=c.client;
    n=c.length;
    foo=io.readInt();
    c.length-=2;
    GC gc=c.lookupGC(foo);
    if(gc==null){
      c.errorValue=foo;
      c.errorReason=13; // GC
      return;
    }
    foo=io.readInt();
    c.length--;
    foo&=0x7fffff;
    if(foo!=0){
      gc.changeAttr(c, foo);
    }
  }
  static void reqCreateGC(Client c) throws IOException{
    int foo;
    IO io=c.client;
    int cid=io.readInt();
    foo=io.readInt();
    c.length-=3;
    Drawable d=c.lookupDrawable(foo);
    if(d==null){
      c.errorValue=foo;
      c.errorReason=9; // Drawable
      return;
    }

    int mask=io.readInt();
    c.length--;
    GC gc=getGC(cid, d);
    mask&=0x7fffff;
    if(mask!=0){
      gc.changeAttr(c, mask);
    }
    Resource.add(gc);
  }

  private void copyAttr(Client c, int vmask, GC srcgc) throws IOException{
    int index=0;
    int foo;
    int mask=vmask;

    while(mask!=0){
      index=lowbit(mask);
      mask&=~index;
      switch(index){
      case GCFunction:
	function=(byte)srcgc.function;
	break;
      case GCPlaneMask:
	break;
      case GCForeground:
	fgPixel=srcgc.fgPixel;
	if((attr&tileIsPixel)==0 && tile.pixmap==null){
	  attr|=tileIsPixel;
	  tile.pixel=fgPixel;
	}
	break;
      case GCBackground:
	bgPixel=srcgc.bgPixel;
	break;
      case GCLineWidth:
	lineWidth=srcgc.lineWidth;
	break;
      case GCLineStyle:
	attr&=~lineStyle;
	attr|=(srcgc.attr&lineStyle);
	break;
      case GCCapStyle:
	attr&=~capStyle;
	attr|=(srcgc.attr&capStyle);
	break;
      case GCJoinStyle:
	attr&=~joinStyle;
	attr|=(srcgc.attr&joinStyle);
	break;
      case GCFillStyle:
	attr&=~fillStyle;
	attr|=(srcgc.attr&fillStyle);
	break;
      case GCFillRule:
	attr&=~fillRule;
	attr|=(srcgc.attr&fillRule);
	break;
      case GCTile:
//	tile=srcgc.tile;
	if((srcgc.attr&tileIsPixel)!=0){
	  tile.pixel=srcgc.tile.pixel;
	}
	else{
	  tile.pixmap=srcgc.tile.pixmap;
	}
	break;
      case GCStipple:
	if(stipple!=null){
	  try{stipple.delete();}catch(Exception e){}
	  stipple=null;
	}
	stipple=srcgc.stipple;
	if(stipple!=null){
	  stipple.ref();
	}
	break;
      case GCTileStipXOrigin:
	tile_stipple_x_origin=srcgc.tile_stipple_x_origin;
	break;
      case GCTileStipYOrigin:
	tile_stipple_y_origin=srcgc.tile_stipple_y_origin;
	break;
      case GCFont:
	font=srcgc.font;
	break;
      case GCSubwindowMode:
	attr&=~subWindowMode;
	attr|=(srcgc.attr&subWindowMode);
	break;
      case GCGraphicsExposures:
	attr&=~graphicsExposures;
	attr|=(srcgc.attr&graphicsExposures);
	break;
      case GCClipXOrigin:
	clip_x_origin=srcgc.clip_x_origin;
	break;
      case GCClipYOrigin:
	clip_y_origin=srcgc.clip_y_origin;
	break;
      case GCClipMask:
	if(clip_mask!=null){
	  try{
	    if(clip_mask instanceof ClipPixmap){
	      ((Pixmap)(clip_mask.getMask())).delete();
	    }
	  }catch(Exception e){}
	  clip_mask=null;
	}
	clip_mask=srcgc.clip_mask;
	if(clip_mask!=null){
	  if(clip_mask instanceof ClipPixmap){
	    ((Pixmap)(clip_mask.getMask())).ref();
	  }
	}
	break;
      case GCDashOffset:
        dash_phase=srcgc.dash_phase;
	break;
      case GCDashList:
        dash=srcgc.dash;
        if(dash!=null){
          float[] bar=new float[dash.length];
          System.arraycopy(dash, 0, bar, 0, bar.length);
          dash=bar;
        }
	break;
      case GCArcMode:
        // not implemented
	break;
      default:
	c.errorValue=vmask;
	c.errorReason=2; // BadValue;
      }
      if(c.errorReason!=0){
	return;
      }
    }

    if(c.length!=0){
      c.errorValue=vmask;
      c.errorReason=2; // BadValue;
    }
    else{
      time=c.seq;
    }
  }

  private void changeAttr(Client c, int vmask) throws IOException{
    int index=0;
    int foo;
    int mask=vmask;
    IO io=c.client;

    while(mask!=0){
      index=lowbit(mask);
      mask&=~index;
      c.length--;
      switch(index){
      case GCFunction:
	foo=io.readInt();
        foo&=0xff;
	function=(byte)foo;
	break;
      case GCPlaneMask:
	foo=io.readInt();
	break;
      case GCForeground:
	foo=io.readInt();
	fgPixel=foo;
	if((attr&tileIsPixel)==0 && tile.pixmap==null){
	  attr|=tileIsPixel;
	  tile.pixel=fgPixel;
	}
//	fgPixel&=0xff;  // depth 8
	break;
      case GCBackground:
	bgPixel=io.readInt();
//	bgPixel&=0xff; // depth 8
	break;
      case GCLineWidth:
	foo=io.readInt();
        foo&=0xffff;
	if(foo==0) foo=1;
	lineWidth=(short)foo;
	break;
      case GCLineStyle:
	foo=io.readInt();
        foo&=0xff;
	foo=(foo<<lineStyleOffset)&lineStyle;
	if(foo!=LineSolid &&
	   foo!=LineOnOffDash &&
	   foo!=LineDoubleDash){
	  c.errorValue=foo>>lineStyleOffset;
	  c.errorReason=2; // BadValue
	  break;
	}	   
	attr&=~lineStyle;
	attr|=foo;
	break;
      case GCCapStyle:
	foo=io.readInt();
        foo&=0xff;
	foo=(foo<<capStyleOffset)&capStyle;
	if(foo!=CapNotLast &&
	   foo!=CapButt &&
	   foo!=CapRound &&
	   foo!=CapProjecting){
	  c.errorValue=foo>>capStyleOffset;
	  c.errorReason=2; // BadValue
	  break;
	}	   
	attr|=foo;

	break;
      case GCJoinStyle:
	foo=io.readInt();
        foo&=0xff;
	foo=(foo<<joinStyleOffset)&joinStyle;
	if(foo!=JoinMiter &&
	   foo!=JoinRound &&
	   foo!=JoinBevel){
	  c.errorValue=foo>>joinStyleOffset;
	  c.errorReason=2; // BadValue
	  break;
	}	   
	attr|=foo;

	break;
      case GCFillStyle:
	foo=io.readInt();
        foo&=0xff;
	attr=(attr&~fillStyle)|(foo<<fillStyleOffset);
	break;
      case GCFillRule:
	foo=io.readInt();
        foo&=0xff;
	break;
      case GCTile:
	foo=io.readInt();
	{
	  Resource o=Resource.lookupIDByType(foo, Resource.RT_PIXMAP);
	  if(o!=null && (o instanceof Pixmap)){
	    Pixmap tmp=(Pixmap)o;
	    if(tmp.depth!=drawable.depth ||
	       tmp.screen!=drawable.screen){
	      c.errorValue=foo;
	      c.errorReason=8; // BadMatch
	      break;
	    }
	    if(tile.pixmap!=null){
	      try{tile.pixmap.delete();}catch(Exception e){}
	    }
	    tile.pixmap=tmp;
	    tile.pixmap.ref();
	    attr&=~tileIsPixel;
	  }
	  else{
	    c.errorValue=foo;
	    c.errorReason=2; // BadValue
	    break;
	  }
	}
	break;
      case GCStipple:
	foo=io.readInt();
	{
	  Resource o=Resource.lookupIDByType(foo, Resource.RT_PIXMAP);
	  if(o!=null && (o instanceof Pixmap)){
	    Pixmap tmp=(Pixmap)o;
	    if(tmp.depth!=1 ||
	       tmp.screen!=drawable.screen){
	      c.errorValue=foo;
	      c.errorReason=8; // BadMatch
	      break;
	    }
	    if(stipple!=null){
	      try{stipple.delete();}catch(Exception e){}
	    }
	    stipple=tmp;
	    stipple.ref();
	  }
	  else{
	    c.errorValue=foo;
	    c.errorReason=2; // BadValue
	    break;
	  }
	}
	break;
      case GCTileStipXOrigin:
	foo=io.readInt();
	tile_stipple_x_origin=(short)(foo&0xffff);
	break;
      case GCTileStipYOrigin:
	foo=io.readInt();
	tile_stipple_y_origin=(short)(foo&0xffff);
	break;
      case GCFont:
	foo=io.readInt();
	font=(Font)Resource.lookupIDByType(foo, RT_FONT);
	if(font==null){
	}
	break;
      case GCSubwindowMode:
	foo=io.readInt();
	foo&=0xff;
	if(foo!=0 && foo!=1){
	}
	attr&=~subWindowMode;
	if(foo==1){ attr|=IncludeInferiors; }
//	else{ attr|=ClipByChildren; }

	break;
      case GCGraphicsExposures:
	foo=io.readInt();
	foo&=0xff;
	if(foo==1) attr|=graphicsExposures;
	if(foo==0) attr&=~graphicsExposures;
	break;
      case GCClipXOrigin:
	foo=io.readInt();
	clip_x_origin=(short)(foo&0xffff);
	break;
      case GCClipYOrigin:
	foo=io.readInt();
	clip_y_origin=(short)(foo&0xffff);
	break;
      case GCClipMask:
	foo=io.readInt();
	if(foo==0){
	  if(clip_mask!=null){
	    try{
	      if(clip_mask instanceof ClipPixmap){
		((Pixmap)(clip_mask.getMask())).delete();
	      }
	    }catch(Exception e){}
	  }
	  clip_mask=null;
	}
	else{
	  Drawable d=c.lookupDrawable(foo);
	  if(d==null || !(d instanceof Pixmap) || d.depth!=1){
	    c.errorValue=foo;
	    c.errorReason=8; // BadMatch
	    break;
	  }
	  if(clip_mask!=null){
	    try{
	      if(clip_mask instanceof ClipPixmap){
		((Pixmap)(clip_mask.getMask())).delete();
	      }
	    }catch(Exception e){}
	  }
	  ((Pixmap)d).ref();
	  clip_mask=new ClipPixmap((Pixmap)d);
	}
	//System.out.println(clip_mask);
	break;
      case GCDashOffset:
	foo=io.readInt();
	foo&=0xffff;
	break;
      case GCDashList:
	foo=io.readInt();
	foo&=0xff;
	break;
      case GCArcMode:
	foo=io.readInt();
	foo&=0xff;
	break;
      default:
	c.length++;
	c.errorValue=vmask;
	c.errorReason=2; // BadValue;
      }
      if(c.errorReason!=0){
	return;
      }
    }

    if(c.length!=0){
      c.errorValue=vmask;
      c.errorReason=2; // BadValue;
    }
    else{
      time=c.seq;
    }
  }

  static private int lowbit(int mask){
    int result=1;
    for(int i=0; i<32; i++){
      if((mask & 1)==1){result=result<<i; break;}
      mask=mask>>1;
    }
    return result;
  }

  static private GC getGC(int id, Drawable d){
    GC gc=get();
    if(gc==null){ return new GC(id, d);}
    gc.id=id; gc.drawable=d;
    gc.init();
    return gc;
  }

  static private GC pool[]=new GC[32];
  static private boolean full=false;

  static private synchronized GC get(){
    GC tmp=null;
    if(full) full=false;
    for(int i=0; i<32; i++){
      if(pool[i]!=null){ tmp=pool[i]; pool[i]=null; break;}
    }
    return tmp;
  }

  static private synchronized void put(GC gc){
    if(full) return;
    for(int i=0; i<32; i++){
      if(pool[i]==null){ pool[i]=gc; return; }
    }
    full=true;
  }
}