// ReaderWriter
//   "Readers and Writers" problem.
//   By Kiwook Kim, December 7 1996
//

import java.awt.*;
import java.awt.image.*;
import java.net.*;

//----------------------------------------------------------
// ReaderWriter
//
public final class ReaderWriter extends java.applet.Applet implements Runnable
{
  // semaphores
  Semaphore wrtSem;
  Semaphore rdSem;

  // number and arrival rate
  int  writerNum;
  int  writerRate;
  int  readerNum;
  int  readerRate;

  // reader and writer threads
  Reader readerTh[];
  Writer writerTh[];


  // several controls
  ControlPanel controlPan;

  // field graphics
  final int fieldX=390,fieldY=330,  
    mainX=390,mainY=440,
    blockX=13,blockY=11;

  // image number
  final int smalls=48;

  // alpha-numeric
  final int alphanum=72;

  // door
  final int doorNum=8;
  final int doorX[]={3,11,3,5,6,8,9,11};
  final int doorY[]={3,3,9,9,8,8,9,9};

  // wall
  final int interWallNum=27;
  final int interWallX[]={3,11, 3,11, 3,11, 1,2,3,11,12,13,
              3,11, 3,4,5,7,9,10,11, 7, 3,5,7,9,11};
  final int interWallY[]={2,2, 4,4, 5,5, 6,6,6,6,6,6, 7,7,
              8,8,8,8,8,8,8, 9, 10,10,10,10,10};

  // maximal number of actors
  final int MaxActors = 20;
  final int MaxWriters = 10;
  final int MaxReaders = 10;

  // write board length in row
  final int boardWidth = 7;
  final int boardDepth = 6;

  // actor move unit
  final int dx = 6;
  final int dy = 6;

  // actor moving time (velocity)
  final int movingTime = 50;

  // animation of penguin
  final int animP[]={7,8,9,8,10,11,12,11,4,5,6,5,1,2,3,2};

  // snoozing time
  final long snooze=100;

  int object[];
  boolean initState;
  int x[],y[],actors, id;
  boolean acting[];
  int look[];
  int sideIX[]={0,-1,1,-15,15},coorDx[]={0,-30,30,0,0},coorDy[]={0,0,0,-30,30};

  Image collection,offImage,playField,small[];
  Image alpha[];
  Graphics offGraphics,playGraphics;
  MediaTracker tracker;
  ImageFilter filter;
  ImageProducer collectionProducer;
  Thread mainTh;

  String text = "Readers and Writers";
  Image timg;

  // -------------------------------------------
  // initialize
  //
  public void init()
  {
    int i, j, k;
    setBackground(Color.black);
    offImage=createImage(mainX,mainY);
    offGraphics=offImage.getGraphics();
    offGraphics.setColor(Color.black);
    offGraphics.fillRect(0,0,mainX,mainY);
    playField=createImage(fieldX,fieldY);
    playGraphics=playField.getGraphics();
    playGraphics.setColor(Color.black);

    // penguin and the other images
    tracker=new MediaTracker(this);
    collection = getImage(getCodeBase(),"field.gif");
    tracker.addImage(collection,0);
    collectionProducer=collection.getSource();
    small=new Image[smalls];
    k=0;i=0;j=0;
    while (k<smalls)
    {
      filter=new CropImageFilter(j*30,i*30,30,30);
      small[k]=createImage(new FilteredImageSource(
        collectionProducer,filter));
      tracker.addImage(small[k],1);

      k++; j++;
      if (j==8) {
        j=0; i++;
      }
    }
    filter=new CropImageFilter(0,180,224,72);

    // alphabet images
    timg = getImage(getCodeBase(),"alpha.gif");
    tracker.addImage(timg,0);
    collectionProducer=timg.getSource();

    alpha=new Image[alphanum];
    k=0;i=0;j=0;
    while (k<alphanum)
    {
      filter=new CropImageFilter(j*30,i*30,30,30);
      alpha[k]=createImage(new FilteredImageSource(
        collectionProducer,filter));
      tracker.addImage(alpha[k],1);

      k++; j++;
      if (j==8) {
        j=0; i++;
      }
    }
    
    object=new int[(blockX+2)*(blockY+3)];
    x=new int[20];
    y=new int[20];
    look=new int[20];

    wrtSem = new Semaphore();
    rdSem = new Semaphore();

    readerTh = new Reader[10];
    writerTh = new Writer[10];

    writerNum = 2;
    writerRate = 5000;
    readerNum = 3;
    readerRate = 3000;

    // several controller buttons and text field
    setLayout(new BorderLayout());
    controlPan = new ControlPanel(this);
    controlPan.set();
    add("South",controlPan);
    controlPan.show();
    initState=true;
    try
    {
      tracker.waitForAll();
    }
    catch(InterruptedException e) {}

    resize(mainX,mainY+100);
  }

  // -------------------------------------------
  // newThread
  //  create new reader and writer thread
  //
  public void newThread()
  {
    int i;
    id = 0;
    for (i = 0; i < 10; i++) {
      readerTh[i] = new Reader(id++, wrtSem, rdSem, this);
      writerTh[i] = new Writer(id++, wrtSem, this);
    }
  }

  // -------------------------------------------
  // run
  //  execute this main thread
  //
  public void run()
  {
    int flag = 0;
    while (mainTh != null) {
      try
      {
        mainTh.sleep(snooze);
      } catch (InterruptedException e) {}

      if (initState) {
        prepareField();
        newThread();
        showField();

        initState = false;
        threadStart();
      }
      repaint();
    }
  }

  // -------------------------------------------
  // threadStart
  //  start reader and writer threads.
  //
  public void threadStart()
  {
    Math m;
    int wr[]; 
    int rr[];
    int rand = 0;
    int i, w, r;
    wr = new int[MaxActors];
    rr = new int[MaxActors];
    
    // initialize
    for (i = 0; i < MaxActors; i++) {
      wr[i] = 0;
      rr[i] = 0;
    }
  
    // get arrival rate from random function
    if (writerNum>0) {
      wr[0] = 10;
      writerTh[0].start(wr[0]);
    }
    for (i = 1; i < writerNum; i++) {
      rand = (int)(Math.random() * 1000 + (writerRate - 1000));
      wr[i] = wr[i-1] + rand;
    }

    if (readerNum>0) {
      rr[0] = 10;
      readerTh[0].start(rr[0]);
    }
    for (i = 1; i < readerNum; i++) {
      rand = (int)(Math.random() * 1000 + (readerRate - 1000));
      rr[i] = rr[i-1] + rand;
    }

    // start threads in order of arrival
    for (i = 0, w = 1, r = 1; i < MaxActors-2; i++) {
      if (wr[w] > 0) {
        if ((wr[w] > rr[r]) && (rr[r] > 0)) {
          readerTh[r].start(rr[r] - rr[r-1]);
          r++;
        }
        else {
          writerTh[w].start(wr[w] - wr[w-1]);
          w++;
        }
      }
      else if (rr[r] > 0) {
        readerTh[r].start(rr[r] - rr[r-1]);
        r++;
      }
    }
  }


  // -------------------------------------------
  // buttonCheck
  //  according to the state, adjust the control button state
  // 
  public void buttonCheck()
  {
    if (actors > 0) {
      controlPan.startB.disable();
      controlPan.pauseB.enable();
      controlPan.resetB.disable();
      controlPan.disableReset();
    }
    else {
      controlPan.startB.enable();
      controlPan.pauseB.disable();
      controlPan.resetB.enable();
    }
  }

  // -------------------------------------------
  // start
  //  start main thread
  //
  public void start()
  {
    if (mainTh==null)
    {
      mainTh=new Thread(this);
      mainTh.start();
    }
  }

  // -------------------------------------------
  // restart
  //  resume the main thread and reader's and
  //  writer's threads.
  //
  public void restart()
  {
    if ((mainTh!=null)&&(mainTh.isAlive()))
    {
      mainTh.resume();
    }
    for (int i = 0; i < MaxReaders; i++) {
      readerTh[i].restart();
    }
    for (int i = 0; i < MaxWriters; i++) {
      writerTh[i].restart();
    }
  }

  // -------------------------------------------
  // pause
  //  suspend all threads.
  //
  public void pause()
  {
    if ((mainTh!=null)&&(mainTh.isAlive()))
    {
      mainTh.suspend();
    }
    for (int i = 0; i < MaxReaders; i++) {
      readerTh[i].pause();
    }
    for (int i = 0; i < MaxWriters; i++) {
      writerTh[i].pause();
    }
  }

  // -------------------------------------------
  // stop
  //  stop main thread.
  //
  public void stop()
  {
    if ((mainTh!=null)&&(mainTh.isAlive()))
    {
      mainTh.stop();
    }
    mainTh=null;
  }

  // -------------------------------------------
  // prepareField
  //  prepare writer and reader field.
  //  set all the position of blocks and doors.
  //
  public void prepareField()
  {
    int i,j,p,q;
    offGraphics.setColor(Color.black);
    offGraphics.fillRect(0,0,mainX,mainY);

    playGraphics.setColor(Color.black);
    playGraphics.fillRect(0,0,fieldX,fieldY);

    offGraphics.setColor(Color.lightGray);
    offGraphics.fill3DRect(0,fieldY,mainX,2,true);

    offGraphics.setColor(Color.lightGray);
    offGraphics.fill3DRect(0,fieldY+30,mainX,2,true);

    offGraphics.setColor(Color.white);
    offGraphics.setFont(new Font("Helvetica", Font.PLAIN, 14));
    offGraphics.drawString("WRITER:",2,fieldY+20);

    offGraphics.setColor(Color.white);
    offGraphics.setFont(new Font("Helvetica", Font.PLAIN, 14));
    offGraphics.drawString("READER:",2,fieldY+50);

    // play area empty
    for (i=1;i<=blockY;i++)
      for (j=1;j<=blockX;j++)
        object[i*(blockX+2)+j]=0;  

    // door
    for (i=0; i < doorNum; i++) {  
      shutDoor(i);
    }
    
    // draw wall
    // border
    for (i=1; i <= blockX; i++) {
      drawBlock(14, blockX+2+i);  // upper wall
      drawBlock(14, i + (blockY)*(blockX+2));  // lower block
      object[blockX+2+i]=1;
      object[i + (blockY)*(blockX+2)]=1;  
    }

    // inter wall
    int interWall = 0;
    for (i=0; i < interWallNum; i++)
    {
      interWall = interWallY[i]*(blockX+2)+interWallX[i];
      object[interWall]=1;
      drawBlock(14, interWall);  
    }

    // initialize all the variables
    for (i=0;i<20;i++)
      look[i]=0;
    actors = 0;
    acting = new boolean[MaxActors];
    for (i=0;i<MaxActors;i++)
      acting[i]=false;
  }


  // -------------------------------------------
  // showField
  //  Show write and read field
  //
  public void showField()
  {
    for (int i = 0; i <= 30; i++) {
      try
      {
        mainTh.sleep(snooze);
      } catch (InterruptedException e) {}
      Graphics saveGraphics;
      saveGraphics=offGraphics.create();

      offGraphics.clipRect(fieldX/2-(i*fieldX/2/30),
        fieldY/2-(i*fieldY/2/30),i*fieldX/30, i*fieldY/30);
      offGraphics.drawImage(playField,0,0,this);

      offGraphics=saveGraphics;
      repaint();
    }
  }

  // -------------------------------------------
  // forward
  //  Check if I can forward, say, check the existence of 
  //  forerunner in destination block.
  //
  synchronized public boolean forward(int from, int to)
  {
    int inFront = object[to];  // object located in destination

    switch (inFront) {
      case 0:    // empty
        object[from] = 0; // free current block
        if ((to != readerTh[id].exitBlock) 
          && (to != writerTh[id].exitBlock))
          object[to] = 1;   // mark next block, if not exit
        return true;
      case 1:   // if rock or other actor (reader or writer) exist 
        return false;
      default:  // door
        return true;
    }
  }

  // -------------------------------------------
  // moveOneBlock
  //  Move one block with the direction "dir".
  //  if cannot move return false; else return true.
  //  Return the block number after moved.
  //
  public int moveOneBlock(int from, int dir, int id) {
    int to = from + sideIX[dir];  // destination block number
    int inFront = object[to];  // object located in destination

    // current coordinate
    x[id] = from % (blockX+2) * 30;
    y[id] = from / (blockX+2) * 30;

    if (forward(from, to) == false)
      return -1;

    // if ice block (door) is in front of me,
    // crack (open) it.
    while ((inFront>1)&&(inFront<18)) // Crack ice
    {
      if (inFront==17)
      {
        playGraphics.fillRect(x[id]+coorDx[dir]-30,y[id]+coorDy[dir]-30,30,30);                  
        object[to] = 0;
        break;
      }
      else
        playGraphics.drawImage(small[inFront+15],x[id]+coorDx[dir]-30,y[id]+coorDy[dir]-30,this);

      inFront++;

      try
      {
        mainTh.sleep(snooze);
      } catch (InterruptedException e) {}
      repaint();
    }

    // while not reaching the destination
    for (int i = 0; i < 5; i++)
    {
      switch(dir)
      {
        case 1:
          x[id]-=dx; break;
        case 2:
          x[id]+=dx; break;
        case 3:
          y[id]-=dy; break;
        case 4:
          y[id]+=dy; break;
        default:
          break;
      }

      look[id] = animP[(dir-1)*4+ i%4];

      try
      {
        mainTh.sleep(movingTime);
      } catch (InterruptedException e) {}

      repaint();
    }

    forward(from, to);
    return to;
  }
  
  // -------------------------------------------
  // readAll
  //  read all the text.
  //
  public void readAll(int id)
  {
    // while not reaching the destination
    for (int i = 0; i < 10; i++)
    {
      look[id] = ((i%2) == 0) ? 0: 39;

      try
      {
        mainTh.sleep(100);
      } catch (InterruptedException e) {}

      repaint();
    }
  }

  // -------------------------------------------
  // paint
  //  paint images.
  //
  public void paint(Graphics g)
  {
    g.drawImage(offImage,0,0,this);
  }

  // -------------------------------------------
  // update
  //  update images.
  //
  public void update(Graphics g)
  {
    if (!initState) {
      offGraphics.drawImage(playField,0,0,this);
      for (int i = 0; i < MaxActors; i++) {
        if (acting[i])
        offGraphics.drawImage(small[look[i]],x[i]-30,y[i]-30,this);
      }
    }
    
    paint(g);
  }

  // -------------------------------------------
  // newActor
  //  new actor has arrived.
  //
  public void newActor(int id)
  {
    actors++;
    acting[id] = true;
    buttonCheck();
  }

  // -------------------------------------------
  // rmvActors
  //  actor exits the field.
  //
  public void rmvActors(int id)
  {
    actors--;
    acting[id] = false;
    buttonCheck();
  }

  // -------------------------------------------
  // shutDoor
  //  shut the door
  synchronized public void shutDoor(int i)
  {
    int j = (doorY[i])*(blockX+2)+doorX[i];
    object[j]=10;
    playGraphics.drawImage(small[24],(doorX[i]-1)*30,(doorY[i]-1)*30,this);
  }

  // -------------------------------------------
  // isDoor
  //  check if it is door.
  //
  public int isDoor(int j)  // return door number
  {
    int x = j % (blockX+2);
    int y = j / (blockX+2);
    for (int i = 0; i < doorNum; i++)
      if ((x==doorX[i]) && (y==doorY[i]))
        return i;
    return -1;
  }

  // -------------------------------------------
  // drawBlock
  //  draw one block.
  //
  public void drawBlock(int sort, int blockNum)  // draw block on blockNum
  {
    int x = blockNum % (blockX+2);
    int y = blockNum / (blockX+2);
    playGraphics.drawImage(small[sort],(x-1)*30,(y-1)*30,this);
  }

  // -------------------------------------------
  // writeDown
  //  draw alphabet image on write screen
  //
  public void writeDown(int blockNum, int index) {
    int x = blockNum % (blockX+2);
    int y = blockNum / (blockX+2);
    playGraphics.drawImage(alpha[index],(x-1)*30,(y-1)*30,this);
  }

  // -------------------------------------------
  // updateComment
  //  update comment under the field.
  //
  synchronized public void updateComment(String str, boolean writer)
  {
    int boxBottom = fieldY+20;
    int strBottom = fieldY+50;
 
    if (writer) {
      offGraphics.setColor(Color.black);
      offGraphics.fillRect(70,boxBottom-15,mainX-60,20);
      offGraphics.setColor(Color.white);
      offGraphics.setFont(new Font("Helvetica", Font.PLAIN, 14));
      offGraphics.drawString(str,70,strBottom-30);
    }
    else {
      offGraphics.setColor(Color.black);
      offGraphics.fillRect(70,boxBottom+15,mainX-60,20);
      offGraphics.setColor(Color.white);
      offGraphics.setFont(new Font("Helvetica", Font.PLAIN, 14));
      offGraphics.drawString(str,70,strBottom);
    }
  }

  // -------------------------------------------
  // setParam
  //  set all the parameters:
  //  - writer number
  //  - reader number
  //  - writer arrival rate
  //  - reader arrival rate
  //
  public void setParam(int wn, int wr, int rn, int rr, String t)
  {
    writerNum = (wn > 10) ? 10: 
          (wn < 0) ? 0: wn;
    writerRate = (wr < 0) ? 1000: wr;
    readerNum = (rn > 10) ? 10: 
          (rn < 0) ? 0: rn;
    readerRate = (wr < 0) ? 1000: rr;

    // trim input text into text "to be written"
    // to fit to write on the board
    int i, len = t.length();
    int limit = boardWidth * boardDepth;
    if (len > limit) {
      StringBuffer dest = new StringBuffer(limit);

      for (i = 0; i < limit; i++) {
        dest.append(t.charAt(i));
      }
      text = dest.toString();
    }
    else
      text = t;
  }
}


//----------------------------------------------------------
// Semaphore
//
class Semaphore {
  private boolean available = true;
  private String str;

  public synchronized void Wait() {
    while (available == false) {
      try {
        wait();
      } catch (InterruptedException e) {
      }
    }
    available = false;
  }

  public synchronized void Signal() {
    available = true;
    notify();
  }
}

// -----------------------------------------------------------
// Writer
//
class Writer extends Thread {
  final int entryBlock = 76;
  final int exitBlock = 59;
  final int writeStarting = 7;

  private ReaderWriter field;  // play ground field
  private int ID;      // writer ID number
  private Semaphore wrtSem;  // write semaphore
  private String text;  // text to be written
  private int blockX;  // block number of X
  private int blockY;  // block number of Y
  private int boardWidth;  // write board length

  private int preDoor0;  // the block number right before door #0
  private int postDoor1;  // the block number right after door #1

  private boolean inWalking;    // writer's motion
  private int mcount;    // move count for writers
  private int writerWalk;  // writer walk number
  private int writerDir[];  // writer walk direction

  Thread writerThread;

  char textChar[];
  int textLen;

  // -------------------------------------------
  // Writer
  //  initialze all the variables.
  //
  public Writer(int id, Semaphore w, ReaderWriter Field) {
    ID = id;
    wrtSem = w;
    field = Field;
    text = Field.text;
    blockX = Field.blockX;
    blockY = Field.blockY;
    boardWidth = Field.boardWidth;

    preDoor0 = 47;
    postDoor1 = 57;

    mcount = 0;
    inWalking = false;
    writerWalk = 0;
    writerDir=new int[200];
    textChar=new char[100];

    textChar = text.toCharArray();
    textLen = textChar.length;

    // decide the writer's route according to the text
    writerRoute(); 
  }

  // -------------------------------------------
  // start
  //  Start thread.
  //
  public void start(int rate)
  {
    // increase actor number 
    field.newActor(ID);

    if (writerThread == null)
    {
      writerThread = new Thread(this);
      writerThread.start();
    }

    try
    {
      writerThread.sleep(rate);
    } catch (InterruptedException e) {}
  }

  // -------------------------------------------
  // restart
  //  resume the suspended thread.
  //
  public void restart()
  {
    if ((writerThread!=null)&&(writerThread.isAlive()))
    {
      writerThread.resume();
    }
  }
 
  // -------------------------------------------
  // pause
  //  suspend the thread.
  //
  public void pause()
  {
    if ((writerThread!=null)&&(writerThread.isAlive()))
    {
      writerThread.suspend();
    }
  }


  // -------------------------------------------
  // run
  //  run the writer thread.
  //
  public void run() {
    // pre-state before entering into the writing field
    preWriting();

    // wait for write
    wrtSem.Wait();

    // writing
    inWriting();

    // signal to write semaphore
    wrtSem.Signal();

    // post writing action
    postWriting();

    field.rmvActors(ID);

  }


  // -------------------------------------------
  // preWriting
  //
  public void preWriting() {
    field.updateComment("New writer has arrived.", true);

    // walk from entry block to before Door #0
    walkThru(entryBlock, preDoor0, false); 

    field.updateComment("Waits for \"write semaphore\".", true);
  }

  // -------------------------------------------
  // inWriting
  //
  public void inWriting() {
    // clear the writing field
    clrscr();    

    field.updateComment("Writing on the board.", true);

    // walk from initPoint to Door #0 field, and write given text
    walkThru(preDoor0, postDoor1, true);  

    field.updateComment("Finished writing.", true);
  }

  // -------------------------------------------
  // postWriting
  //
  public void postWriting() {
    field.updateComment("Signals for \"write semaphore\".", true);

    // walk from post Door #1 to exit
    walkThru(postDoor1, exitBlock, false);  

    field.updateComment("Exits the field.", true);
  }

  // -------------------------------------------
  // walkThru
  //   walk from "from" block to "to" block.
  //   if "isWrite" is set, write down text on write screen
  //
  public void walkThru(int from, int to, boolean isWrite) {
    int count = 0;  // letter count
    int prev = from;  // previous position
    int curPos = from;  // current position
    int dir;

    while (curPos != to) {
      dir = writerDir[mcount++];
      while((curPos = field.moveOneBlock(prev, dir, ID)) < 0) {
        try {
          sleep(100);
        } catch (InterruptedException e) {
        }
      }

      // if the writer in a write_down state
      if ((isWrite) && (mcount >= writeStarting) &&
        (dir != 1) &&
        (count < textLen)) {
        field.writeDown(prev, alphaIndex(textChar[count]));
        count++;
      }

      // if "prev" is Door location, shut door
      else if (field.isDoor(prev) >= 0)
        field.shutDoor(field.isDoor(prev));

      prev = curPos;
    }
  }

  // -------------------------------------------
  // alphaIndex
  //  input : character
  //  output : corresponding index of "alpha" image
  //
  public int alphaIndex(char c) {
    int i = 0;
    if ((c >96) && (c < 123)) {  // 'a' to  'z'
      i = c - 97 + 26;
    }
    else if ((c > 64) && (c < 91)) {   // 'A' to 'Z'
      i = c - 65;
    }
    else if ((c > 47) && (c < 58)) {   // '0' to '9'
      i = c - 48 + 52;
    }
    else {
      switch (c) {
        case '!': i = 62; break;
        case ',': i = 64; break;
        case '.': i = 65; break;
        case '?': i = 66; break;
        case '"': i = 67; break;
	    //        case ''': i = 68; break;
        case '$': i = 69; break;
        case '*': i = 70; break;
        case '&': i = 71; break;
        default: i = 63;  // space
      }
    }

    return i;
  }

  // -------------------------------------------
  // alphaIndex
  // input : string to write
  // output : writer's route
  //
  public void writerRoute () {
    int line = 1;
    int outDoorY = 2;
    int i = 0;

    // initialize the write route direction
    writerWalk = 0;

    writerDir[writerWalk++] = 3;
    writerDir[writerWalk++] = 3;
    writerDir[writerWalk++] = 2;
    writerDir[writerWalk++] = 2;
    writerDir[writerWalk++] = 2;
    writerDir[writerWalk++] = 3;

    for (i = 0; i < textLen; i++) {
      if ((i % boardWidth == boardWidth-1) && (i != 0) && (i < textLen-1)) {
        writerDir[writerWalk++] = 4;
        for (int k = 0; k < boardWidth-1; k++) {
          writerDir[writerWalk++] = 1;
        }
        line++;
      }
      else if (i < textLen-1)
        writerDir[writerWalk++] = 2;
      else {
        if (line < outDoorY) {
          writerDir[writerWalk++] = 4;
          line++;
        }
        else if (line > outDoorY) {
          writerDir[writerWalk++] = 3;
          line--;
        }
      }
    }

    // once writing is done
    for (; ((i-1)%boardWidth) != boardWidth-1; i++)  // looking for out-door
      writerDir[writerWalk++] = 2;

    if (line > outDoorY) {  // go up to find door
      for (i = outDoorY; i < line; i++)
        writerDir[writerWalk++] = 3;
    }
    else if (line < outDoorY) {  // go down to find door
      for (i = line; i < outDoorY; i++)
        writerDir[writerWalk++] = 4;
    }

    for (i = 0; i < 6; i++)  // go out thru door
      writerDir[writerWalk++] = 2;
  }

  // -------------------------------------------
  // clrscr
  //  clear write screen
  //
  public void clrscr() {
    int l,m,n;
    for (l = 0; l < 6*(blockX+2); l+= blockX+2) {
      for (m = 34+l; m < 41+l; m++) {
        int x = m % (blockX+2);
        int y = m / (blockX+2);
        field.playGraphics.drawImage(field.alpha[63],(x-1)*30,(y-1)*30,field);
      }
    }
  }
}


//----------------------------------------------------------
// Reader
//
class Reader extends Thread {
  final int entryBlock = 106;
  final int exitBlock = 149;

  final int readerWalk = 34;
  final int readerDir[] = {4,4,2,2,2,2,2,3,3,3,1,1,3,3,2,2,2,2,2,2,
          4,4,1,1,4,4,4,2,2,2,2,2,2,2};

  private static int readerCount;

  private int ID;
  private Semaphore wrtSem;
  private Semaphore rdSem;
  private ReaderWriter field;

  private int preDoor2;
  private int preDoor3;
  private int postDoor4;
  private int preDoor5;
  private int postDoor6;
  private int postDoor7;
  private int mcount;

  Thread readerThread;

  // -------------------------------------------
  // Reader
  //  initialize all the variables.
  //
  public Reader(int id, Semaphore w, Semaphore r, ReaderWriter Field) {
    readerCount = 0;

    ID = id;
    wrtSem = w;
    rdSem = r;
    field = Field;

    preDoor2 = 137;
    preDoor3 = 139;
    postDoor4 = 111;
    preDoor5 = 113;
    postDoor6 = 145;
    postDoor7 = 147;

    mcount = 0;
  }

  // -------------------------------------------
  // start
  //  Start thread.
  //
  public void start(int rate)
  {
    // increase actor number 
    field.newActor(ID);

    if (readerThread == null)
    {
      readerThread = new Thread(this);
      readerThread.start();
    }

    try
    {
      readerThread.sleep(rate);
    } catch (InterruptedException e) {}
  }

  // -------------------------------------------
  // restart
  //  resume suspended thread.
  //
  public void restart()
  {
    if ((readerThread!=null)&&(readerThread.isAlive()))
    {
      readerThread.resume();
    }
  }
 
  // -------------------------------------------
  // pause
  //  suspend the thread.
  //
  public void pause()
  {
    if ((readerThread!=null)&&(readerThread.isAlive()))
    {
      readerThread.suspend();
    }
  }

  // -------------------------------------------
  // run
  //  execute this thread.
  //
  public void run() {
    // pre-state before entering into the reading field
    preReading();

    // before reading
    // wait for read semaphore
    rdSem.Wait();
    preWaiting();

    readerCount++;
    if (readerCount == 1) {
      wrtSem.Wait();
    }
    preWaiting2();
    rdSem.Signal();

    // reading
    inReading();

    // after reading
    // wait for read semaphore
    rdSem.Wait();
    postWaiting();

    readerCount--;
    if (readerCount == 0) {
      wrtSem.Signal();
    }
    postWaiting2();
    rdSem.Signal();

    postReading();

    field.rmvActors(ID);
  }

  // -------------------------------------------
  // preReading
  //
  public void preReading() {
    field.updateComment("New reader has just arrived.", false);
    walkThru(entryBlock, preDoor2);
  }

  // -------------------------------------------
  // preWaiting
  //
  public void preWaiting() {
    field.updateComment("Waits for \"read semaphore\".", false);
    walkThru(preDoor2, preDoor3);
  }

  // -------------------------------------------
  // preWaiting2
  //
  public void preWaiting2() {
    field.updateComment("Waits for \"write semaphore\".", false);
    walkThru(preDoor3, postDoor4);
    field.updateComment("Reader signals \"read semaphore\".", false);
  }

  // -------------------------------------------
  // inReading
  //
  public void inReading() {
    field.updateComment("Reading the text.", false);
    walkThru(postDoor4, preDoor5);
  }

  // -------------------------------------------
  // postWaiting
  //
  public void postWaiting() {
    field.updateComment("Waits for \"read semaphore\".", false);
    walkThru(preDoor5, postDoor6);
  }

  // -------------------------------------------
  // postWaiting2
  //
  public void postWaiting2() {
    field.updateComment("Signals \"write semaphore\".", false);
    walkThru(postDoor6, postDoor7);
  }

  // -------------------------------------------
  // postReading
  //
  public void postReading() {
    field.updateComment("Signals \"read semaphore\".", false);
    field.readAll(ID);
    walkThru(postDoor7, exitBlock);
    field.updateComment("Exits the field.", false); 
  }

  // -------------------------------------------
  // walkThru
  //  walk from "from" block to "to" block.
  //
  public void walkThru(int from, int to) {
    int prev = from;  // previous position
    int curPos = from;  // current position
    int dir;

    while (curPos != to) {
      dir = readerDir[mcount++];
      while((curPos = field.moveOneBlock(prev, dir, ID)) < 0) {
        try {
          sleep(100);
        } catch (InterruptedException e) {
        }
      }

      // if "prev" is Door location, close door
      if (field.isDoor(prev) >= 0)
        field.shutDoor(field.isDoor(prev));

      prev = curPos;
    }
  }
}


//----------------------------------------------------------
// ControlPanel
//
class ControlPanel extends Panel {
  private boolean inAnApplet = true;

  ReaderWriter field;
  TextField t;
  TextField rr,rn,wr,wn;
  Button resetB, pauseB, startB;
  
  // -------------------------------------------
  // ControlPanel
  //  initialize all the panel.
  //
  public ControlPanel(ReaderWriter Field) {
    field = Field;

    GridBagLayout gridbag = new GridBagLayout();
    GridBagConstraints c = new GridBagConstraints();

    setLayout(gridbag);

    setFont(new Font("Helvetica", Font.BOLD, 14));
    setBackground(Color.lightGray);

    c.fill = GridBagConstraints.BOTH;

    c.weightx = 1.0;
    makeLabel("Writer No.", gridbag, c);
    wn = makeTextField(Integer.toString(field.writerNum), gridbag, c, 2);
    makeLabel("Writer Rate", gridbag, c);
    c.gridwidth = GridBagConstraints.REMAINDER; //end of row
    wr = makeTextField(Integer.toString(field.writerRate), gridbag, c, 5);

    c.gridwidth = 1;
    makeLabel("Reader No.", gridbag, c);
    rn = makeTextField(Integer.toString(field.readerNum), gridbag, c, 2);
    makeLabel("Reader Rate", gridbag, c);
    c.gridwidth = GridBagConstraints.REMAINDER; //end of row
    rr = makeTextField(Integer.toString(field.readerRate), gridbag, c, 5);

    c.gridwidth = 1;
    makeLabel("Text", gridbag, c);
    c.gridwidth = GridBagConstraints.REMAINDER; //end of row
    t = makeTextField(field.text, gridbag, c, 40);

    c.gridwidth = 2;
    c.gridheight = 2;
    c.weighty = 1.0;
    pauseB = makeButton("Pause", gridbag, c);


    c.weighty = 0.0;
    c.gridwidth = GridBagConstraints.REMAINDER; //end of row
    c.gridheight = 1;
    resetB = makeButton("Reset", gridbag, c);
    startB = makeButton("Start", gridbag, c);

    // initialize all the buttons
    pauseB.enable();
    startB.disable();
    resetB.disable();
    disableReset();
  }

  // -------------------------------------------
  // action
  //  action when button is pushed or
  //  text field is overwritten.
  //
  public boolean action(Event ev, Object arg) {
    Object target = ev.target;
    String label = (String) arg;

    if (target == resetB) {
      if (label == "Reset") {
        resetB.setLabel("Set");
        enableReset();
        startB.disable();
      }
      if (label == "Set") {
        resetB.setLabel("Reset");
        field.setParam( Integer.parseInt(wn.getText().trim()),
          Integer.parseInt(wr.getText().trim()),
          Integer.parseInt(rn.getText().trim()),
          Integer.parseInt(rr.getText().trim()),
          t.getText().trim());
        wn.setText(Integer.toString(field.writerNum));
        rn.setText(Integer.toString(field.readerNum));
        wr.setText(Integer.toString(field.writerRate));
        rr.setText(Integer.toString(field.readerRate));
        t.setText(field.text);
        startB.enable();
        disableReset();
      }
      return true;
    }
    if (target == pauseB) {
      if (label == "Resume") {
        pauseB.setLabel("Pause");
        field.restart();
      }
      else {
        pauseB.setLabel("Resume");
        field.pause();
      }
      return true;
    }
    if (target == startB) {
       field.initState = true;
       field.start();
      return true;
    }
 
    return false;
  }

  // -------------------------------------------
  // makeButton
  //
  protected Button makeButton(String name,
                GridBagLayout gridbag,
                GridBagConstraints c) {
    Button button = new Button(name);
    button.setForeground(Color.blue);
    gridbag.setConstraints(button, c);
    add(button);
    return button;
  }

  // -------------------------------------------
  // makeTextField
  //
  protected TextField makeTextField(String name,
                GridBagLayout gridbag,
                GridBagConstraints c, 
                int width) {
    TextField textField = new TextField(name, width);
    textField.setForeground(Color.blue);
    gridbag.setConstraints(textField, c);
    add(textField);
    return textField;
  }

  // -------------------------------------------
  // makeLabel
  //
  protected void makeLabel(String name,
                GridBagLayout gridbag,
                GridBagConstraints c) {
    Label label = new Label(name, Label.CENTER);
    label.setForeground(Color.blue);
    gridbag.setConstraints(label, c);
    add(label);
  }

  // -------------------------------------------
  // enableReset
  //  enable all the textFields.
  //
  public void enableReset() {
    wn.enable();
    wr.enable();
    rn.enable();
    rr.enable();
    t.enable();
  }

  // -------------------------------------------
  // disableReset
  //  disable all the textFields.
  //
  public void disableReset() {
    wn.disable();
    wr.disable();
    rn.disable();
    rr.disable();
    t.disable();
  }

  // -------------------------------------------
  // handleEvent
  //
  public boolean handleEvent(Event e) {
    if (e.id == Event.WINDOW_DESTROY) {
      if (inAnApplet) {
        return true;
      } else {
        System.exit(0);
      }
    }   
    return super.handleEvent(e);
  }
  
  // -------------------------------------------
  // set
  //
  public void set() {
    inAnApplet = false;
  }
}