scheduler.java

无限传感器网络的模拟结果的图形查看环境

      class LThread implements Runnable {
 
	public void run() {

	  for (int i=0;i<Preferences.layout_iteration;i++) {

	    Enumeration e=m_nodes.elements();
	    while (e.hasMoreElements()) {
	      Node curnode=(Node)e.nextElement();

	      // Generate a new position by moving the nodes a bit

	      double randx=curnode.getX()+(Math.random()*10.0)-5;
	      double randy=curnode.getY()+(Math.random()*10.0)-5;

	      // Clip coordinates to panel size

	      if (randx<10) randx=10;
	      else 
	      if (randx>m_panel.getWidth()-10) 
	      randx=m_panel.getWidth()-10;

	      if (randy<10) randy=10;
	      else 
	      if (randy>m_panel.getHeight()-10) 
	      randy=m_panel.getHeight()-10;

	      curnode.setX(randx);
	      curnode.setY(randy);
	    }

	    m_panel.re_paint();

	    try {
	      Thread.sleep(Preferences.fps);
	    } catch(InterruptedException exc) {}

	  }
	}
      }

      // Start layout thread (TODO: Join the thread when it's done!!)

      Thread t=new Thread(new LThread());
      t.start();
    }
    

    /**
       paint is called back by a panel to tell the Scheduler to redraw all
       its elements. It shouldn't be used for other purposes.
       @param g the graphics context to use for drawing.
    */
    public void paint(Graphics g) {

      // Fill background
      g.setColor(new Color(0xdddddd));
      g.fillRect(0,0,m_panel.getWidth(),m_panel.getHeight());

      g.setColor(Color.black);
   
      // Set font
      g.setFont(new java.awt.Font("SansSerif",java.awt.Font.PLAIN,8));

      // Get font settings
      java.awt.FontMetrics metrics=g.getFontMetrics();

      // Draw nodes

      for (Enumeration e=m_nodes.elements();e.hasMoreElements();) {
	Node n=(Node)e.nextElement();

	n.draw(g,metrics);
      }

      // Draw links

      for (Enumeration e=m_links.elements();e.hasMoreElements();) {
	Link l=(Link)e.nextElement();

	l.draw(g,metrics);
      }

      // Draw all the queues

      if (m_queues!=null) 
      for (Enumeration e=m_queues.elements();e.hasMoreElements();) {
	Queue q=(Queue)e.nextElement();

	q.draw(g,metrics);
      }


      // Draw dynamic elements (packets, etc.)

      if (m_elements!=null)
      for (Enumeration e=m_elements.elements();e.hasMoreElements();) {
	VisualElement ve=(VisualElement)e.nextElement();

	ve.draw(g,metrics);
      }

      g.setColor(Color.white);
    }

  
    /**
       handleEvent is used privately to dispatch events and updates elements.
       It admittedly shows rather bad design. This function needs redesigning.
       Lots of instanceof testing and casting is used. Events should maybe
       be handled by VisualElement classes themselves.
     */
    private void handleEvent(Event ev) {

      if (ev instanceof LinkEvent) {
	LinkEvent le=(LinkEvent)ev;

	// Find the correct link through one of the nodes involved

	Node s=(Node)m_nodes.get(new Integer(le.getSource()));
	if (s==null) return;

	Link l=s.getLink(le.getDestination());
	if (l==null) return;

	// Update status

	//l.setColour(le.getColour());
	l.setStatus(le.getStatus());
      }
      else
      if (ev instanceof TextEvent) {
        TextEvent te=(TextEvent)ev;

	// Just add a Text object to the elements

        Text t=(Text)te.returnElement();

        m_elements.addElement(t);
      }
      else 
      if (ev instanceof NodeEvent) {
	NodeEvent ne=(NodeEvent)ev;

	// Update the node colour

	Node n=(Node)m_nodes.get(new Integer(ne.getNodeID()));

	n.setColour(ne.getColour());
      }
      else
      if (ev instanceof StopEvent) {
        StopEvent se=(StopEvent)ev;

        this.stopPlaying();
      }
      else 
      if (ev instanceof PacketEvent) {
	PacketEvent pe=(PacketEvent)ev;

	// Packet events can be different kinds of events

	switch (pe.getEventType()) {

	case PacketEvent.ENQUE: { Queue q=(Queue)m_queues.get(new Integer(pe.getSource()));
	                          Node s=(Node)m_nodes.get(new Integer(pe.getSource()));
	                          // Queue not enable for display
	                          if (q==null) break;

				  // Add packet to the queue

				  q.setNodePosition(s.getX(),s.getY());
				  Packet p=(Packet)pe.returnElement();
				  q.enqueue(p);
	                        }
	                        break;

	case PacketEvent.DEQUE: {
	                          Queue q=(Queue)m_queues.get(new Integer(pe.getSource()));
	                          // Queue not enabled for display
	                          if (q==null) break;

				  Packet p=(Packet)pe.returnElement();
				  q.dequeue(p);
	                        }
	                        break;

	  case PacketEvent.HOP: Packet p=(Packet)pe.returnElement();
	                        Node s=(Node)m_nodes.get(new Integer(p.getSource()));
				Node d=(Node)m_nodes.get(new Integer(p.getDestination()));
				Link l=s.getLink(p.getDestination());

				if (l==null) return;

				// Calculate the direction the packet is moving

				Vector v=new Vector();
				v.m_value[0]=d.getX()-s.getX();
				v.m_value[1]=d.getY()-s.getY();

				// Set all the initial parameters of the packet

       				p.setStartPosition(s.getX(),s.getY());
				p.setDirection(v);
				p.setLink(l);
				p.setLeaveTime(pe.getTime());
				p.setTransmitTime((double)(pe.getSize()*8)/
						  l.getBandwidth());

				double t_time=l.getDelay()+
				  ((double)p.getSize()*8.0)/l.getBandwidth();

				p.setArriveTime(pe.getTime()+t_time);

				p.readyToGo();
				
				m_elements.addElement(p);
	                        
				break;

	 case PacketEvent.DROP: int packetID=pe.getPacketID();
	                        Queue q=(Queue)m_queues.get(new Integer(pe.getSource()));
				// Find out if the packet is dropping from a
				// queue or from a link..

				if (q!=null && q.getQueuedPacket(packetID)!=null) {
  				Packet dp=q.getQueuedPacket(packetID);
				  // Dropping from a queue

				  double endX=(double)q.getEndX();
				  double endY=(double)q.getEndY();
				  dp.setDropStart(endX,endY);
				  dp.setStatus(Packet.PACKET_DROPPED);
				  q.drop(dp);
				  m_elements.addElement(dp);
				}
				else {
				  Packet dp=null;

				  // Dropping from a link

				  for(int i=0; i<m_elements.size(); i++) {
                                    if(m_elements.elementAt(i) instanceof Packet) {
				      if(((Packet)m_elements.elementAt(i)).getID()==packetID)
					dp=(Packet)m_elements.elementAt(i);
                                    }
				  }
				  if (dp!=null)
				  dp.setStatus(Packet.PACKET_DROPPED);
				}
				break;
	}
	
      }
    }


    /**
       run contains the main animation loop and is the entry point for the
       animation thread. It is public because this class implements the
       Runnable interface but should not be called directly.
    */
    public void run() {
      Event ev=null;
      Debug.out.println(m_timeinc);

      do {

	// Handle any leftover events

	if (ev!=null && ev.getTime()<=m_time) {
	  handleEvent(ev);
	  ev=null;
	}

	// Grab new events

	if (ev==null)
	do {
	  ev=m_fileio.nextEvent(m_time);
	  if (ev==null) break;

	  if (ev.getTime()<=m_time)
	  handleEvent(ev);

	} while (ev.getTime()<=m_time);

	if (ev==null) break;


	// Simple update the time until the current time is greater than the
	// next event's time.

	while (m_time<ev.getTime()) {

	  m_time+=m_timeinc;
	  m_iface.setTimeBar(m_time);

	  if (m_elements!=null)
	  for (int i=0;i<m_elements.size();i++) {
	    VisualElement ve=(VisualElement)m_elements.elementAt(i);

	    ve.update(m_time);

	    if (!ve.isValid(m_time)) {
	      m_elements.removeElementAt(i);
	      i--;
	    }

	    if(ve instanceof Packet)
	      ((Packet)ve).setTimeInc(m_timeinc);
	  }

	  if (!m_seekflag) {

	    // Redraw the screen

	    m_panel.re_paint();

	    // Now wait a bit

	    try {
	      Thread.sleep(Preferences.fps);
	    }
	    catch (InterruptedException e) {}
	  }
	}

	m_seekflag=false;

      } while(ev!=null);

      m_filestatus=FILE_EOF;
      this.stopPlaying();
    }
}