trainpanel.java

The WLAN Traffic Visualizer is a platform independent Java program providing accurate measurement of

				f.frameDur,
				BARH);

		if (view.showTransactions()) {
			g2d.setPaint(fColor);
			g2d.draw(sFrameSouth);
		}

		if (viewSpan>1E4 || !view.showPacketDetails()) {
			g2d.setPaint(fColor);
			g2d.fill(sFrame);
			g2d.draw(sFrame);
		}
		else {
			Shape sPreamble = new Rectangle2D.Float(
					preambleLeft,
					upper,
					f.getPreambleDur(),
					BARH);

			Shape sPlcpHeader = new Rectangle2D.Float(
					plcpLeft,
					upper,
					f.getPlcpDur(),
					BARH);

			Shape sPsdu = new Rectangle2D.Float(
					left,
					upper,
					f.psduDur,
					BARH);

			if (!(f.fType==FType.FILL)) {
				g2d.setPaint(Gray230230230);
				g2d.fill(sPreamble);
				g2d.setPaint(fColor);
				g2d.fill(sPsdu);
				g2d.setPaint(Gray200200200);
				g2d.fill(sPlcpHeader);
			}

			g2d.setPaint(fColor);
			g2d.draw(sFrame);

			if (f.wlanDuration>0) {
				g2d.setPaint(Color.BLACK);
				Shape sDuration = new Rectangle2D.Float(
						right,
						upper-UNIT/2,
						f.wlanDuration,
						UNIT/2);
				g2d.draw(sDuration);
			}
		}

		if (f.wlanToDs == 1 && f.wlanFromDs == 1) {
			g2d.setPaint(Color.RED);
			Shape shape = new Rectangle2D.Float(preambleLeft,(upper+lower)/2f,right-preambleLeft,0);
			g2d.draw(shape);
			g2d.fill(shape);
		}
		else if (f.wlanToDs == 1 && f.wlanFromDs == 0) {
			g2d.setPaint(Color.RED);
			Shape shape = new Rectangle2D.Float(preambleLeft,upper,right-preambleLeft,BARH/5f);
			g2d.draw(shape);
			g2d.fill(shape);
		}
		else if (f.wlanToDs == 0 && f.wlanFromDs == 1) {
			g2d.setPaint(Color.RED);
			Shape shape = new Rectangle2D.Float(preambleLeft,lower-BARH/5f,right-preambleLeft,BARH/5f);
			g2d.draw(shape);
			g2d.fill(shape);
		}

		if (viewSpan<5E5 && view.showPacketDetails() && f.wlanSeq!=0) {
			g2d.setFont(f90);
			g2d.setPaint(Color.BLACK);
			g2d.drawString(Integer.toString(f.wlanSeq),left,lower);
		}
	}

	private void drawTransaction (Graphics2D g2d, OneTransaction one, int i) {
		Shape sTransactionSouth = new Rectangle2D.Float(
				one.timeStamp,
				PANELH-5*UNIT-i*UNIT,
				one.totalDur,
				UNIT);

		Shape sAccessTimeSouth = new Rectangle2D.Float(
				one.timeStamp-one.backOffTime-one.difsDur,
				PANELH-5*UNIT-i*UNIT,
				one.backOffTime+one.difsDur,
				UNIT);

		g2d.setColor(Color.LIGHT_GRAY);
		g2d.fill(sAccessTimeSouth);
		if (one.type == Type.FULL) 
			g2d.setColor(Color.BLACK);
		else if (one.type == Type.RECONSTRUCTED) 
			g2d.setColor(Color.GREEN);
		else if (one.type == Type.ABORTED) 
			g2d.setColor(Color.BLUE);

		g2d.fill(sTransactionSouth);
	}

	public void setFirstLimit(int x) {
		firstLimit = screenToXpos(x);
	}

	public void setSecondLimit(int x, int i) {
		secondLimit = screenToXpos(x);
		if (i == MouseEvent.BUTTON1) {
			if (Math.abs(firstLimit-secondLimit) > MINIUMUM_SPAN) {
				viewStartTime = Math.min(firstLimit,secondLimit);
				viewEndTime = Math.max(firstLimit,secondLimit);
				viewSpan = viewEndTime - viewStartTime;
				setFirstAndLastViewTransactionNo();
				buffer = null;
				repaint();
			}
		}
		else if (i == MouseEvent.BUTTON2) {
			JOptionPane.showMessageDialog(
					this,
					"Left pos:"+Math.min(firstLimit,secondLimit)+"\n"+
					"Right pos:"+Math.max(firstLimit,secondLimit)+"\n"+
					"Span:"+Math.abs(firstLimit-secondLimit));
		}
		else if (i == MouseEvent.BUTTON3) {
			viewStartTime += firstLimit-secondLimit;
			viewEndTime = viewStartTime + viewSpan; 
			viewSpan = viewEndTime - viewStartTime;
			buffer = null;
			repaint();
		}
	}

	private void setFirstAndLastViewTransactionNo() {
		if (transaction.getCaptureLastTransactionNo() != 0) {

			// Find first transaction by searching upwards
			for (int i=0; i<=transaction.getCaptureLastTransactionNo(); i++) {
				OneTransaction one = transaction.list.get(i);
				if (one.type != Type.RECONSTRUCTED  &&  one.timeStamp >= viewStartTime) {
					viewFirstTransactionNo = i;
					break;
				}
			}

			// Find last transaction by searching downwards
			for (int i=transaction.getCaptureLastTransactionNo(); i>=0; i--) {
				OneTransaction one = transaction.list.get(i);
				if (one.type != Type.RECONSTRUCTED  &&  one.timeStamp+one.totalDur <= viewEndTime) {
					viewLastTransactionNo = i;
					break;
				}
			}

			//			System.out.println(viewFirstTransactionNo +"-"+ viewLastTransactionNo);
		}
	}

	public void zoomIn(int x) {
		double xPos = screenToXpos(x);
		double div = (xPos-viewStartTime)/viewSpan;
		long st0 = (long)(xPos - div*viewSpan/ZOOM_FACTOR);
		long et0 = st0 + (long)(viewSpan/ZOOM_FACTOR);
		if (et0-st0 > MINIUMUM_SPAN) {
			viewStartTime = st0;
			viewEndTime = et0;
			viewSpan = viewEndTime - viewStartTime;
			setFirstAndLastViewTransactionNo();
			buffer = null;
			repaint();
		}
	}

	public void zoomIn() {
		long et0 = viewEndTime - viewSpan/2;
		if (et0-viewStartTime > MINIUMUM_SPAN) {
			viewEndTime = et0;
			viewSpan = viewEndTime - viewStartTime;
			buffer = null;
			repaint();
		}
	}

	public void zoomOut(int x) {
		double xPos = screenToXpos(x);
		double div = (xPos-viewStartTime)/viewSpan;
		viewStartTime = (long)(xPos - ZOOM_FACTOR*div*viewSpan);
		viewEndTime = viewStartTime + (long)(ZOOM_FACTOR*viewSpan);
		viewSpan = viewEndTime - viewStartTime;
		setFirstAndLastViewTransactionNo();
		buffer = null;
		repaint();
	}

	public void zoomOut() {
		viewEndTime += viewSpan;
		viewSpan = viewEndTime - viewStartTime;
		setFirstAndLastViewTransactionNo();
		buffer = null;
		repaint();
	}

	//	void moveLeft() {
	//		viewStartTime = viewStartTime - viewSpan/3;
	//		viewEndTime = viewEndTime - viewSpan/3;
	//		viewSpan = viewEndTime - viewStartTime;
	//		buffer = null;
	//		repaint();
	//	}

	//	void moveRight() {
	//		viewStartTime = viewStartTime + viewSpan/3;
	//		viewEndTime = viewEndTime + viewSpan/3;
	//		viewSpan = viewEndTime - viewStartTime;
	//		buffer = null;
	//		repaint();
	//	}

	private long screenToXpos(int x) {
		return viewStartTime + viewSpan*x/getWidth();
	}

	private long screenToYpos(int y) {
		return PANELH*y/getHeight();
	}


	public class LocateResult {
		OneTransaction one;
		Packet packet;
	}

	LocateResult locateFrame(int x, int y) {
		if (transaction.list != null) {
			long xPos = screenToXpos(x);
			long yPos = screenToYpos(y);
			long minDist = Long.MAX_VALUE;
			LocateResult result = new LocateResult();

			for (int j=viewFirstTransactionNo; j<=viewLastTransactionNo; j++) {
				OneTransaction one = transaction.list.get(j);
				if (!one.hide)
					for (Packet r : one.packetList) {
						long y1 = VBARSEP*DrawSupport.getDrawVpos(r.fType);
						long y2 = VBARSEP*DrawSupport.getDrawVpos(r.fType)+BARH;
						if (yPos>=y1 && yPos<=y2) {
							long dist = Math.abs(r.timeStamp+r.frameDur/2-xPos);
							if (dist < minDist) {
								minDist = dist;
								result.packet = r;
								result.one = one;
							}
							else if (result.packet!=null) return result;
						}
						//						}
					}
			}
			if (result.packet!=null) return result;

			minDist = Long.MAX_VALUE;
			if (view.getAddedPackets() != null)
				for (Packet r : view.getAddedPackets()) {
					if (r.timeStamp+r.frameDur >= viewStartTime && r.timeStamp <= viewEndTime) {
						long y1 = VBARSEP*DrawSupport.getDrawVpos(r.fType);
						long y2 = VBARSEP*DrawSupport.getDrawVpos(r.fType)+BARH;
						if (yPos>=y1 && yPos<=y2) {
							long dist = Math.abs(r.timeStamp+r.frameDur/2-xPos);
							if (dist < minDist) {
								minDist = dist;
								result.packet = r;
							}
							else if (result.packet!=null) return result;
						}
					}
				}
			if (result.packet!=null) return result;
		}
		return null;
	}

	LocateResult locateTransaction(int x, int y) {
		final int TRANS_UPPER_YPOS = PANELH-5*UNIT-2*UNIT;
		final int TRANS_LOWER_YPOS = PANELH-5*UNIT+UNIT;

		if (transaction.list != null) {
			long xPos = screenToXpos(x);
			long yPos = screenToYpos(y);

			if (yPos>=TRANS_UPPER_YPOS && yPos<TRANS_LOWER_YPOS) {
				for (int j=viewFirstTransactionNo; j<=viewLastTransactionNo; j++) {
					OneTransaction one = transaction.list.get(j);
					if (!one.hide && xPos >= one.timeStamp && xPos < one.timeStamp+one.totalDur) {
						LocateResult result = new LocateResult();
						result.packet = one.packetList.get(0);
						result.one = one;
						return result;
					}
				}
			}
		}
		return null;
	}

	public void componentHidden(ComponentEvent arg0) {
	}

	public void componentMoved(ComponentEvent arg0) {
	}

	public void componentResized(ComponentEvent arg0) {
		buffer = null;
		repaint();
	}

	public void componentShown(ComponentEvent arg0) {
	}

	class Refresh extends TimerTask {
		@Override
		public void run() {
			//			System.out.println("Refresh");
			repaint();
		}
	}

	public Packet getViewFirstPacket() {
		if (viewLastTransactionNo != 0) {
			ArrayList<Packet> l = transaction.list.get(viewFirstTransactionNo).packetList;
			return l.get(0);
		}
		else {
			return null;
		}
	}

	public Packet getViewLastPacket() {
		if (viewLastTransactionNo != 0) {
			ArrayList<Packet> l = transaction.list.get(viewLastTransactionNo).packetList;
			return l.get(l.size()-1);
		}
		else {
			return null;
		}
	}

	public int getViewFirstTransactionNo() {
		return viewFirstTransactionNo;
	}

	public int getViewLastTransactionNo() {
		return viewLastTransactionNo;
	}
	
}