packetrenderapplet.java

本程序是用java编写的一些关于arq协议实现的小程序

    public SimplePacketThread(PacketRenderApplet applet, int packet_no, int sleepDuration) {
           super (applet, new Packet(packet_no, "PACKET"), applet.left + packet_no*applet.gap, applet.top + applet.packetSize, applet.bottom); 
           this.sleepDuration = sleepDuration;
    }

    public SimplePacketThread(PacketRenderApplet applet, int packet_no) {
           super (applet, new Packet(packet_no, "PACKET"), applet.left + packet_no*applet.gap, applet.top + applet.packetSize, applet.bottom); 
    }

    public void run () {
        try {
           if (sleepDuration != 0) {
              applet.swin.stopTimer(packet.packet_no);
              Thread.sleep(sleepDuration);
              applet.swin.resumeTimer(packet.packet_no);
           }
        }
        catch (Exception e) {}
        super.run();
    }
}

class SimpleAckThread extends PacketDrawingThread {
    public SimpleAckThread(PacketRenderApplet applet, int packet_no) {
           super (applet, new Packet(packet_no, "ACK"), applet.left + packet_no*applet.gap, applet.bottom - applet.packetSize, applet.top); 
    }
}

public class PacketRenderApplet extends Applet implements ActionListener, ItemListener 
{
    private Image buffer;

    public Graphics gBuffer;
    public Object paintLock;

    public int top = 50;
    public int bottom;
    public int left = 30;
    public int gap = 25;

    public int numPackets = 10;
    public int packetSize = 15;
    public int window_size;
    public int speed;

    public SenderWindow swin;
    public ReceiverWindow rwin;

    private Vector threadContainer;
    private int start;
    private int constructed = 0;

    private Panel buttonPanel = new Panel (new GridLayout(2,1));
    private Panel buttonPanel1 = new Panel (new GridLayout(1,5));
    private Panel buttonPanel2 = new Panel (new GridLayout(1,3));

    private Button startButton = new Button("Start");
    private Button stopButton = new Button("Stop");
    private Button resetButton = new Button("Reset");
    private Button speedUpButton = new Button("Speed Up");
    private Button speedDownButton = new Button("Speed Down");

    private Button deleteButton = new Button("Delete");
    public Choice packetType = new Choice();
    private Choice packetNumbers = new Choice();

    public void init()
    {
        buffer = createImage(size().width, size().height);
        gBuffer = buffer.getGraphics();
        paintLock = new Object();
        threadContainer = new Vector(numPackets * 2);

        setLayout(new BorderLayout());
        buttonPanel.add(buttonPanel1);
        buttonPanel.add(buttonPanel2);
        add(buttonPanel, BorderLayout.SOUTH);

        bottom = size().height - top - 75;
        window_size = 4;
        speed = 2;
        start = 1;

        if (swin != null) {
           swin.removeAllTimers();
        }

        swin = new SenderWindow(this, 0, window_size);
        rwin = new ReceiverWindow(this, 0, window_size);

        drawInitialScreen();
        createInitialThreads();

        if (constructed == 0) {
           addButtons();
           constructed = 1;
        }

        packetType.select("PACKET");
        fillPacketNumbersList("PACKET");
    }


    private void drawInitialScreen () {
        gBuffer.setColor(Color.black);
        gBuffer.fillRect(0, 0, size().width, size().height);
        for (int i=0; i<numPackets; ++i) {
               gBuffer.setColor(Color.gray);
               gBuffer.fillRect(left + i*gap, top, packetSize, packetSize);
               gBuffer.fillRect(left + i*gap, bottom, packetSize, packetSize);
               gBuffer.setFont(new Font(null, Font.BOLD, 14));
               gBuffer.setColor(Color.black);
               gBuffer.drawString(String.valueOf(i), left + i*gap + packetSize/4, top + packetSize - 3);
               gBuffer.drawString(String.valueOf(i), left + i*gap + packetSize/4, bottom + packetSize - 3);
        }
        gBuffer.setColor(Color.gray);
        gBuffer.draw3DRect (left - 5 , top - 5, gap * window_size, packetSize + 10, true); 
        gBuffer.draw3DRect (left - 5 , bottom - 5, gap * window_size, packetSize + 10, true); 
    }

    private void createInitialThreads() {
        Thread thread;
        for (int i=0; i<window_size; ++i) {
            addThread(new SimplePacketThread(this, i, 400*i));
        }
    }

    public void actionPerformed(ActionEvent event) {
        String actionCommand = event.getActionCommand();

           if (actionCommand.equals("Start")) {
              startButton.setEnabled(false);
              stopButton.setEnabled(true);
              resetButton.setEnabled(false);
              speedUpButton.setEnabled(true);
              speedDownButton.setEnabled(true);

              start_applet();
           }
           else if (actionCommand.equals("Stop")) {
              stopButton.setEnabled(false);
              startButton.setEnabled(true);
              resetButton.setEnabled(true);
              speedUpButton.setEnabled(false);
              speedDownButton.setEnabled(false);

              stop();
           }
           else if (actionCommand.equals("Reset")) {
                startButton.setEnabled(true);
                stopButton.setEnabled(false);
                resetButton.setEnabled(false);
                speedUpButton.setEnabled(false);
                speedDownButton.setEnabled(false);

                init();
           }
           else if (actionCommand.equals("Speed Up")) {
                if (speed < 6) {
                   speed ++;
                }
                speedDownButton.setEnabled(true);
                if (speed == 6)
                   speedUpButton.setEnabled(false);
           }
           else if (actionCommand.equals("Speed Down")) {
                if (speed > 1) {
                   speed --;
                }
                speedUpButton.setEnabled(true);
                if (speed == 1)
                   speedDownButton.setEnabled(false);
           }
           else if (actionCommand.equals("Delete")) {
                synchronized (paintLock) {
                    deleteThread(packetType.getSelectedItem(), packetNumbers.getSelectedItem());
                    repaint();
                    fillPacketNumbersList(packetType.getSelectedItem());
                }
           }
    }

    public void itemStateChanged (ItemEvent event) {
           String selectedItem = (String) event.getItem();
           fillPacketNumbersList(selectedItem);
    }

    private void addButtons() {
            buttonPanel1.add(startButton);
            buttonPanel1.add(stopButton);
            buttonPanel1.add(resetButton);
            buttonPanel1.add(speedUpButton);
            buttonPanel1.add(speedDownButton);

            packetType.add("PACKET");
            packetType.add("ACK");
            buttonPanel2.add(packetType);
            buttonPanel2.add(packetNumbers);
            buttonPanel2.add(deleteButton);
            
            startButton.addActionListener(this);
            stopButton.addActionListener(this);
            resetButton.addActionListener(this);
            speedUpButton.addActionListener(this);
            speedDownButton.addActionListener(this);

            deleteButton.addActionListener(this);
            packetType.addItemListener(this);
    }

    public void fillPacketNumbersList (String packetType) {
        Enumeration e = threadContainer.elements();

        packetNumbers.removeAll();
        while (e.hasMoreElements()) {
            PacketDrawingThread thread = (PacketDrawingThread) e.nextElement(); 
            if (thread.packet.type == packetType) {
                packetNumbers.add(String.valueOf(thread.packet.packet_no));
            }
        }
    }

    private Thread findThread (String packet_type, String packet_no) {
        Enumeration e = threadContainer.elements();

        while (e.hasMoreElements()) {
            PacketDrawingThread thread = (PacketDrawingThread) e.nextElement(); 
            if ((thread.packet.type == packet_type)&&(thread.packet.packet_no == Integer.parseInt(packet_no))) {
               return thread;
            }
        }

        return null;
    }

    public void addThread(Thread thread) {
        threadContainer.addElement(thread);
    }

    public void removeThread(Thread thread) {
        threadContainer.removeElement(thread);
    }

    public void start_applet() {
    
        Enumeration e = threadContainer.elements();

        while (e.hasMoreElements()) {
              if (start == 1) {
                 PacketDrawingThread thread = (PacketDrawingThread) e.nextElement();
                 thread.start();
                 swin.addTimer(thread.packet.packet_no);
              }
              else {
                 ((PacketDrawingThread) e.nextElement()).resumeThread();
              }
        }

        if (start == 0) {
           swin.startAllTimers();
        }

        start = 0;
    }

    public void start() {
            startButton.setEnabled(true);
            stopButton.setEnabled(false);
            resetButton.setEnabled(false);
            speedUpButton.setEnabled(false);
            speedDownButton.setEnabled(false);
    }

    public void endButtonState() {
            startButton.setEnabled(false);
            stopButton.setEnabled(false);
            resetButton.setEnabled(true);
            speedUpButton.setEnabled(false);
            speedDownButton.setEnabled(false);
            drawStatus("Finished!", Color.white);
    }

    public void stop() {
        Enumeration e = threadContainer.elements();

        while (e.hasMoreElements()) {
            ((PacketDrawingThread) e.nextElement()).suspendThread();
        }
        swin.stopAllTimers();
    }

    public void destroy() {
        stop();

        Enumeration e = threadContainer.elements();
        while (e.hasMoreElements()) {
            Thread thread = (Thread) e.nextElement();
            threadContainer.removeElement(thread);
        }
        swin.removeAllTimers();
    }

    public void deleteThread (String packet_type, String packet_no) {
        if (packet_no != null) {

           PacketDrawingThread thread = (PacketDrawingThread) findThread(packet_type, packet_no); 

           if (thread != null) {
              thread.disappear();
              removeThread(thread);

              if (packet_type.equals("PACKET")) {
                  drawStatus("Alert: Packet " + packet_no + " is lost!", Color.red); 
              }
              else if (packet_type.equals("ACK")) {
                   drawStatus("Alert: Ack " + packet_no + " is lost!", Color.red); 
              }
           }
        }
    }

    public void callback_function (PacketDrawingThread t) {
        if (t.packet.type.equals("PACKET")) {
           rwin.receivePacket(t.packet);
        }

        if (t.packet.type.equals("ACK")) {
           swin.receivePacket(t.packet);
        }
        removeThread(t);
        fillPacketNumbersList(packetType.getSelectedItem());
    }

    public void drawStatus (String status, Color color) {
           gBuffer.setColor(Color.black);
           gBuffer.fillRect(left, bottom + top - 12, size().width, 12);
           gBuffer.setFont(new Font(null, Font.BOLD, 12));
           gBuffer.setColor(color);
           gBuffer.drawString(status, left, bottom + top);
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    public void paint(Graphics g)
    {
        synchronized(paintLock) { 
           gBuffer.setFont(new Font(null, Font.BOLD, 20));
           gBuffer.setColor(Color.red);
           gBuffer.drawString("Selective Repeat Protocol", left, top/2);
           if (swin.finished == 0) {
              swin.drawWindow (Color.gray);
           }
           if (rwin.finished == 0) {
              rwin.drawWindow (Color.gray);
           }
           g.drawImage(buffer, 0, 0, this);
        }
    }
}