mudcolorizer.java

The Javatm Telnet Application/Applet 很好用的

package de.mud.jta.plugin;

import de.mud.jta.FilterPlugin;
import de.mud.jta.Plugin;
import de.mud.jta.PluginBus;
import de.mud.jta.PluginConfig;
import de.mud.jta.event.ConfigurationListener;
import de.mud.jta.event.EndOfRecordListener;
import gnu.regexp.RE;

import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;

/**
 * Some little hack for colors and prompts.
 * We are using GNU, so we should release this under the GPL :)
 * <ul>
 * <li>needs gnu.regexp package (approx. 22 kB)
 * <li>handles prompt with EOR (maybe buggy, but testet with mglib 3.2.6)
 * <li>colorizes single lines using regular expressions
 * </ul>
 * @author Thomas Kriegelstein
 */
public class MUDColorizer extends Plugin
        implements FilterPlugin, EndOfRecordListener, ConfigurationListener {

  public static String BLACK = "";
  public static String RED = "";
  public static String BRED = "";
  public static String GREEN = "";
  public static String BGREEN = "";
  public static String YELLOW = "";
  public static String BYELLOW = "";
  public static String BLUE = "";
  public static String BBLUE = "";
  public static String PINK = "";
  public static String BPINK = "";
  public static String CYAN = "";
  public static String BCYAN = "";
  public static String WHITE = "";
  public static String BWHITE = "";
  public static String NORMAL = "";
  public static String BOLD = "";

  /*  Prompthandling:
   *  if we do have a prompt, in every read of a new line, write a
   *  Clearline (ie. \r\e[K), then write the text and then
   *  rewrite the prompt after the last \n
   */

  private Object[] exps = null;

  public MUDColorizer(PluginBus bus, final String id) {
    super(bus, id);
    bus.registerPluginListener(this);
  }

  public void setConfiguration(PluginConfig cfg) {
    String tmp;
    if ((tmp = cfg.getProperty("MUDColorizer", id, "regexpSet")) != null) {
      Properties regexpSet = new Properties();

      try {
        regexpSet.load(getClass().getResourceAsStream(tmp));
      } catch (Exception e) {
        try {
          regexpSet.load(new URL(tmp).openStream());
        } catch (Exception ue) {
          error("cannot find regexpSet: " + tmp);
          error("resource access failed: " + e);
          error("URL access failed: " + ue);
          regexpSet = null;
        }
      }

      if (regexpSet != null && !regexpSet.isEmpty()) {
        exps = new Object[regexpSet.size() * 2];
        Hashtable colors = new Hashtable();
        colors.put("BLACK", BLACK);
        colors.put("RED", RED);
        colors.put("BRED", BRED);
        colors.put("GREEN", GREEN);
        colors.put("BGREEN", BGREEN);
        colors.put("YELLOW", YELLOW);
        colors.put("BYELLOW", BYELLOW);
        colors.put("BLUE", BLUE);
        colors.put("BBLUE", BBLUE);
        colors.put("PINK", PINK);
        colors.put("BPINK", BPINK);
        colors.put("CYAN", CYAN);
        colors.put("BCYAN", BCYAN);
        colors.put("WHITE", WHITE);
        colors.put("BWHITE", BWHITE);
        colors.put("NORMAL", NORMAL);
        colors.put("BOLD", BOLD);

        Enumeration names = regexpSet.propertyNames();
        int ex = 0;
        while (names.hasMoreElements()) {
          String exp = (String) names.nextElement();
          RE re = null;
          try {
            re = new RE(exp);
          } catch (Exception e) {
            System.err.println("Something wrong with regexp: " +
                               ex + "\t" + exp);
            System.err.println(e);
          }
          exps[ex++] = re;
          exps[ex++] = colors.get(regexpSet.get(exp));
          System.out.println("MUDColorizer: loaded: " + exp + " with " + regexpSet.get(exp));
        }
      }
    }
  }

  FilterPlugin source;

  public void setFilterSource(FilterPlugin source) {
    this.source = source;
  }

  public FilterPlugin getFilterSource() {
    return source;
  }

  public void EndOfRecord() {
    readprompt = true;
  }

  private byte[] transpose(byte[] buf) {
    byte[] nbuf;
    int nbufptr = 0;
    nbuf = new byte[8192];

    /* Prompthandling I */
    if (promptwritten && prompt != null && prompt.length > 0) {
      // "unwrite"
      nbuf[nbufptr++] = (byte) '\r';
      nbuf[nbufptr++] = 27;
      nbuf[nbufptr++] = (byte) '[';
      nbuf[nbufptr++] = (byte) 'K';
      promptwritten = false;
    }
    if (readprompt) {
      int index;
      for (index = buf.length - 1; index >= 0; index--)
        if (buf[index] == '\n') break;
      index++;
      prompt = new byte[buf.length - index];
      System.arraycopy(buf, index, prompt, 0, buf.length - index);
      readprompt = false;
      writeprompt = true;
      promptwritten = false;
      promptread = true;
      // System.out.println("Neues Prompt: $"+new String(prompt)+"$");
    }
    /* /Prompthandling I */

    /* Colorhandling should be done herein
     * Problem:  Strings aren磘 allways transposed completely
     *           sometimes a \n is in the next transpose buffer
     * Solution: Buffer lines outside like read does
     */
    if (promptwritten) {
      lp = 0;
      line[0] = 0;
    }

    for (int i = 0; i < buf.length; i++, lp++) {
      // nbuf[nbufptr++] = buf[i];
      line[lp] = buf[i];
      if (line[lp] == '\n') {
        String l = new String(line, 0, lp + 1);
        boolean colored = false;
        boolean useexp = (exps != null);
        for (int ex = 0; !colored && useexp && ex < exps.length; ex += 2) {
          RE exp = (RE) exps[ex];
          if (null != exp.getMatch(l)) {
            byte[] color = (byte[]) ((String) exps[ex + 1]).getBytes();
            System.arraycopy(color, 0, nbuf, nbufptr, color.length);
            nbufptr += color.length;
            System.arraycopy(line, 0, nbuf, nbufptr, lp + 1);
            nbufptr += lp + 1;
            byte[] normal = NORMAL.getBytes();
            System.arraycopy(normal, 0, nbuf, nbufptr, normal.length);
            nbufptr += normal.length;
            colored = true;
          }
        }
        if (!colored) {
          System.arraycopy(line, 0, nbuf, nbufptr, lp + 1);
          nbufptr += lp + 1;
        }
        colored = false;
        lp = -1;
        line[0] = 0; // gets overwritten soon;
      }
    }
    if (promptread) {
      lp = 0;
      line[0] = 0;
      promptread = false;
    }
    /* /Colorhandling */

    /* Prompthandling II */
    if (buf[buf.length - 1] == '\n') writeprompt = true;
    if (buf[buf.length - 1] == '\r') writeprompt = true;
    if (writeprompt && prompt != null && prompt.length > 0) {
      // "rewrite"
      nbuf[nbufptr++] = (byte) '\r';
      nbuf[nbufptr++] = 27;
      nbuf[nbufptr++] = (byte) '[';
      nbuf[nbufptr++] = (byte) 'K';
      System.arraycopy(prompt, 0, nbuf, nbufptr, prompt.length);
      nbufptr += prompt.length;
      promptwritten = true;
      writeprompt = false;
    }
    /* /Promphandling II */

    byte[] xbuf = new byte[nbufptr];
    System.arraycopy(nbuf, 0, xbuf, 0, nbufptr);
    return xbuf;
  }

  // einzufaerbende zeile
  private int lp = 0;
  private byte[] line = new byte[8192];
  // prompt handeln
  private boolean readprompt = false;
  private boolean promptread = false;
  private boolean writeprompt = false;
  private boolean promptwritten = false;
  private byte[] prompt = null;
  // bufferoverflows handeln
  private byte[] buffer = null;
  private int pos = 0;

  public int read(byte[] b) throws IOException {
    // empty the buffer before reading more data
    if (buffer != null) {
      int amount = (buffer.length - pos) <= b.length ?
              buffer.length - pos : b.length;
      System.arraycopy(buffer, pos, b, 0, amount);
      if (pos + amount < buffer.length) {
        pos += amount;
      } else {
        buffer = null;
        pos = 0;
      }
      return amount;
    }

    // now we are sure the buffer is empty and read on
    int n = source.read(b);
    if (n > 0) {
      byte[] tmp = new byte[n];
      System.arraycopy(b, 0, tmp, 0, n);
      buffer = transpose(tmp);
      if (buffer != null && buffer.length > 0) {
        int amount = buffer.length <= b.length ? buffer.length : b.length;
        System.arraycopy(buffer, 0, b, 0, amount);
        pos = n = amount;
        if (amount == buffer.length) {
          buffer = null;
          pos = 0;
        }
      } else
        return 0;
    }
    return n;
  }

  public void write(byte[] b) throws IOException {
    if (b[b.length - 1] == '\n') {
      writeprompt = true;
      promptwritten = false;
    }
    source.write(b);
  }
}