fastcommandscreen.java

一个基于J2ME技术的程序,使你可以远程控制装有服务端的PC.

/*
 * JRemCntl - Copyright (C) 2007 Filippo Di Vattimo <[e-mail]>
 * See COPYING
 */

package fildiv.jremcntl.client.ui;

import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;

import fildiv.jremcntl.client.core.AppContext;
import fildiv.jremcntl.common.core.Command;
import fildiv.jremcntl.common.core.Context;
import fildiv.jremcntl.common.core.JRemMobileKeys;

public class FastCommandScreen extends CommandScreen {

	private final static long LIST_ITEMS_TIMER_MILLIS = 2000;

	private final static long TICKER_TIMER_MILLIS = 200;

	private final static int CANVAS_BGCOLOR = 0xffffcc;

	private final static int CANVAS_FGCOLOR = 0x0000cc;

	private final static int CANVAS_BGCOLOR_HEADER = 0x00cccc;

	protected static final int INSET_X = 1;

	protected static final int INSET_Y = 1;

	public static final int TICKER_STATE_SHOW = 1;

	public static final int TICKER_STATE_RESET = 2;

	public static final int TICKER_STATE_WAIT = 3;

	public static final int TICKER_WAIT_CICLES = 7;

	private Font font;

	private CommandCanvas cmdsCanvas;

	private Vector commandsDesc;

	private Timer listItemsTimer;

	private TimerTask listItemsTimerTask;

	private Timer tickerTimer;

	private TimerTask tickerTimerTask;

	private String tickerMessage = "";

	private class CommandCanvas extends Canvas {

		public static final short REPAINT_HINT_LIST_ITEM = 1;

		public static final short REPAINT_HINT_TICKER = 2;

		private Command cmd = null;

		private boolean started;

		private short repaintHint;

		// List items

		private Vector commandsDesc = new Vector();

		private int lastCmdIndex = 0;

		private boolean enoughSpace = true;

		// Ticker

		private String tickerMessage = "";

		private int tickerStartIndex = 0;

		private int tickerEndIndex = 0;

		private boolean firstListItemsRepaint;

		private int tickerState = TICKER_STATE_SHOW;

		private int tickerWaitCicles = TICKER_WAIT_CICLES;

		private class ListItemsTimerTask extends TimerTask {

			public void run() {
				onTimerListItems();
			}
		};

		private class TickerTimerTask extends TimerTask {

			public void run() {
				onTimerTicker();
			}
		};

		public CommandCanvas() {

			initTimers();
			reset();
		}

		private void initTimers() {

			listItemsTimerTask = new ListItemsTimerTask();
			listItemsTimer = new Timer();

			tickerTimerTask = new TickerTimerTask();
			tickerTimer = new Timer();
		}

		public synchronized void reset() {

			if (listItemsTimerTask != null)
				listItemsTimerTask.cancel();

			if (listItemsTimer != null)
				listItemsTimer.cancel();

			if (tickerTimerTask != null)
				tickerTimerTask.cancel();

			if (listItemsTimer != null)
				tickerTimer.cancel();

			listItemsTimerTask = null;
			listItemsTimer = null;
			tickerTimerTask = null;
			tickerTimer = null;

			resetTicker();

			started = false;
		}

		public synchronized void start() {

			if (started)
				return;

			initTimers();

			listItemsTimer.schedule(listItemsTimerTask,
					LIST_ITEMS_TIMER_MILLIS, LIST_ITEMS_TIMER_MILLIS);
			tickerTimer.schedule(tickerTimerTask, TICKER_TIMER_MILLIS,
					TICKER_TIMER_MILLIS);

			syncRepaint(REPAINT_HINT_LIST_ITEM);
			
			started = true;
		}

		public void keyPressed(int keyCode) {

			cmd = getCommand(translateKey(keyCode));
			if (cmd != null)
				execCommand(cmd);

			syncRepaint(REPAINT_HINT_LIST_ITEM);
		}

		private void writeHeaderRow(Graphics g, int row, String s) {
			writeRow(g, row, s, CANVAS_BGCOLOR_HEADER);
		}

		private void writeRow(Graphics g, int row, String s) {
			writeRow(g, row, s, CANVAS_FGCOLOR);
		}

		private void writeRow(Graphics g, int row, String s, int bgc) {

			if (row >= getMaxRows())
				return;

			g.setFont(font);
			g.setColor(bgc);
			int y = getRowY(row);

			g.drawString(s, 2, y + 1, Graphics.LEFT | Graphics.TOP);
		}

		public synchronized void setRepaintHint(short repaintHint) {
			this.repaintHint = repaintHint;
		}

		public short getRepaintHint() {
			return repaintHint;
		}

		public String getTickerMessage() {
			return tickerMessage;
		}

		public void setCommandsDesc(Vector commandsDesc) {

			synchronized (commandsDesc) {
				this.commandsDesc = commandsDesc;
			}
		}

		public synchronized void setTickerMessage(String tickerMessage) {

			this.tickerMessage = tickerMessage;

			resetTicker();
		}

		private int getMaxVisibileChars(Font f, String str) {

			int width = 0;
			int charCount = 0;

			for (int index = 0; index < str.length(); ++index) {
				char c = str.charAt(index);

				width += f.charWidth(c);

				if (width > getWidth())
					break;

				++charCount;
			}

			return charCount;
		}

		private String fixToWidth(char c) {

			int charWidth = font.charWidth(c);
			int width = 0;

			StringBuffer sb = new StringBuffer();

			while (true) {
				width += charWidth;
				if (width > getWidth())
					break;

				sb.append(c);
			}

			return sb.toString();
		}

		public void paint(Graphics g) {

			Context ctx = getContext();

			if (ctx == null)
				return;

			int tickerStartRow = 0;
			g.setColor(CANVAS_BGCOLOR);

			if (repaintHint == REPAINT_HINT_TICKER) {

				g.fillRect(0, getRowY(tickerStartRow), getWidth(),
						getRowY(tickerStartRow + 1));

				writeTicker(g, tickerStartRow);

			} else {

				int currRow = tickerStartRow + 1; // reserves first row for
													// the ticker
				g.fillRect(0, getRowY(currRow), getWidth(), getHeight());

				int maxRows = getMaxRows();

				writeHeaderRow(g, currRow++, ctx.getDesc());
				writeCommands(g, currRow, maxRows - 2);

				String lastCommand = "none";

				if (cmd != null)
					lastCommand = buildCmdLabel(cmd);

				writeHeaderRow(g, maxRows - 1, ": " + lastCommand);
			}
		}

		/*
		 * Implementation
		 */

		private int getRowY(int row) {

			int y = row * (font.getHeight() + INSET_Y);
			return y;
		}

		private int getMaxCols(Font f) {

			char averageChar = ' ';

			int cols = (int) (getWidth() / f.charWidth(averageChar));

			return cols;
		}

		private int getMaxRows() {

			int rows = (int) ((getHeight() / (font.getHeight() + INSET_Y)));
			return rows;
		}

		private synchronized void syncRepaint(short repaintHint) {

			this.repaintHint = repaintHint;
			repaint();
		}

		private void onTimerListItems() {

			if (!cmdsCanvas.hasEnoughSpace() || !firstListItemsRepaint)
				syncRepaint(REPAINT_HINT_LIST_ITEM);

			firstListItemsRepaint = true;
		}

		private void onTimerTicker() {
			syncRepaint(REPAINT_HINT_TICKER);
		}

		private void resetTicker() {

			tickerState = TICKER_STATE_SHOW;
			tickerWaitCicles = TICKER_WAIT_CICLES;
			tickerStartIndex = 0;
			tickerEndIndex = 0;
		}

		private void writeTicker(Graphics g, int row) {

			switch (tickerState) {

			case TICKER_STATE_RESET:

				writeRow(g, row, fixToWidth(' '));

				tickerState = TICKER_STATE_SHOW;
				tickerStartIndex = 0;
				tickerEndIndex = 0;

				break;

			case TICKER_STATE_SHOW:

				String str = tickerMessage.substring(tickerStartIndex);
				int maxVisibleChars = getMaxVisibileChars(font, str);

				if (tickerMessage.length() <= maxVisibleChars) {

					writeRow(g, row, str);

				} else {

					tickerEndIndex = tickerStartIndex + maxVisibleChars + 1;
					if (tickerEndIndex > tickerMessage.length()) {

						tickerEndIndex = tickerMessage.length();

						tickerState = TICKER_STATE_WAIT;
						tickerWaitCicles = TICKER_WAIT_CICLES;

						writeTickerPart(g, row, tickerStartIndex,
								tickerEndIndex);

					} else {

						writeTickerPart(g, row, tickerStartIndex,
								tickerEndIndex);
						tickerStartIndex++;
					}
				}

				break;

			case TICKER_STATE_WAIT:

				writeTickerPart(g, row, tickerStartIndex, tickerEndIndex);

				if (tickerWaitCicles-- <= 0)
					tickerState = TICKER_STATE_RESET;

				break;
			}
		}

		private void writeTickerPart(Graphics g, int row, int tickerStartIndex,
				int tickerEndIndex) {
			String subStr = tickerMessage.substring(tickerStartIndex,
					tickerEndIndex);
			writeRow(g, row, subStr);
		}

		private void writeCommands(Graphics g, int currRow, int maxRow) {

			if (commandsDesc == null)
				return;

			synchronized (commandsDesc) {

				for (int index = 0; index < commandsDesc.size(); ++index) {

					if (index < lastCmdIndex)
						continue;

					int row = currRow++;

					if (row > maxRow) {
						lastCmdIndex = index;
						enoughSpace = false;
						return;
					}

					String desc = (String) commandsDesc.elementAt(index);
					writeRow(g, row, desc);

				}

				lastCmdIndex = 0;
			}
		}

		public boolean hasEnoughSpace() {
			return enoughSpace;
		}

		private String translateKey(int keyCode) {

			String key = "";

			switch (keyCode) {

			case Canvas.KEY_NUM0:
				key = JRemMobileKeys.KEY_0;
				break;
			case Canvas.KEY_NUM1:
				key = JRemMobileKeys.KEY_1;
				break;
			case Canvas.KEY_NUM2:
				key = JRemMobileKeys.KEY_2;
				break;
			case Canvas.KEY_NUM3:
				key = JRemMobileKeys.KEY_3;
				break;
			case Canvas.KEY_NUM4:
				key = JRemMobileKeys.KEY_4;
				break;
			case Canvas.KEY_NUM5:
				key = JRemMobileKeys.KEY_5;
				break;
			case Canvas.KEY_NUM6:
				key = JRemMobileKeys.KEY_6;
				break;
			case Canvas.KEY_NUM7:
				key = JRemMobileKeys.KEY_7;
				break;
			case Canvas.KEY_NUM8:
				key = JRemMobileKeys.KEY_8;
				break;
			case Canvas.KEY_NUM9:
				key = JRemMobileKeys.KEY_9;
				break;
			case Canvas.KEY_STAR:
				key = JRemMobileKeys.KEY_S;
				break;
			case Canvas.KEY_POUND:
				key = JRemMobileKeys.KEY_P;
				break;
			}

			if (!"".equals(key))
				return key;

			switch (getGameAction(keyCode)) {
			case Canvas.UP:
				key = JRemMobileKeys.KEY_UP;
				break;
			case Canvas.DOWN:
				key = JRemMobileKeys.KEY_DOWN;
				break;
			case Canvas.LEFT:
				key = JRemMobileKeys.KEY_LEFT;
				break;
			case Canvas.RIGHT:
				key = JRemMobileKeys.KEY_RIGHT;
				break;
			case Canvas.FIRE:
				key = JRemMobileKeys.KEY_FIRE;
				break;
			}

			return key;
		}
	};

	public FastCommandScreen(AppContext appCtx) {
		super(appCtx);

		font = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_SMALL);

		cmdsCanvas = new CommandCanvas();
	}

	public void setContext(Context ctx) {

		super.setContext(ctx);

		addCommands(cmdsCanvas);

		commandsDesc = new Vector();
		Vector commands = ctx.getCommands();

		for (int index = 0; index < commands.size(); ++index) {

			Command c = (Command) commands.elementAt(index);

			if (c.getKey() != null && !c.getKey().equals(""))
				commandsDesc.addElement(buildCmdLabel(c));
		}

		clearAll();
	}

	protected Command getCommand(String c) {

		Command cmd = null;

		Vector commands = getContext().getCommands();

		int index;
		for (index = 0; index < commands.size(); ++index) {
			cmd = (Command) commands.elementAt(index);

			String key = cmd.getKey();
			if (key == null || "".equals(key))
				continue;

			if (key.substring(0, 1).equals(c))
				return cmd;
		}

		return null;
	}

	protected void onActivate() {

		getDisplay().setCurrent(cmdsCanvas);

		if (getAppCtx().inDebug())
			tickerMessage = "This is a debug message in ticker!!! "
					+ "The message must be long to allows scrolling. End message!";

		cmdsCanvas.setCommandsDesc(commandsDesc);
		cmdsCanvas.setTickerMessage(tickerMessage);
		cmdsCanvas.start();
	}

	protected void onDeactivate() {

		super.onDeactivate();
		reset(false);
	}

	public synchronized void setTickerMessage(String tickerMessage) {

		if (tickerMessage == null)
			tickerMessage = "";

		this.tickerMessage = tickerMessage;

		if (cmdsCanvas == null)
			return;

		cmdsCanvas.setTickerMessage(tickerMessage);
	}

	public void reset(boolean clearAll) {

		cmdsCanvas.reset();

		if (clearAll)
			clearAll();
	}

	private void clearAll() {

		synchronized (tickerMessage) {
			this.tickerMessage = "";
		}
	}
}