serverplayercontainer.java

ErGo是一个很早的Java通用围棋服务器(IGS/NNGS)客户端程序。有全部源码和文档

package ergo.ui;

// $Id: ServerPlayerContainer.java,v 1.3 1999/08/13 01:20:10 sigue Exp $

/*
 *  Copyright (C) 1999  Carl L. Gay and Antranig M. Basman.
 *  See the file copyright.txt, distributed with this software,
 *  for further information.
 */

import ergo.*;
import ergo.server.*;
import ergo.logic.*;
import ergo.util.*;
import java.util.Hashtable;
import java.util.Enumeration;
import java.awt.*;
import java.awt.event.*;

/**
 * Implements the Who View window.
 *
 * @see ServerGameContainer
 */
public class ServerPlayerContainer
  implements MultiCallBackable, MultiWindowBackable, Optionizable {

  public static final int SORT_NAME = 0;
  public static final int SORT_RANK = 1;
  public static final int SORT_OPEN = 2;
  public static final int SORT_PLAYING = 3;

  private static final String[] sortMethods = { "by Name", "by Rank" };

  Hashtable serverPlayer = new Hashtable(); // hashtable lookup by name

  //public ServerPlayer serverPlayerAt (int i) {
  //  return (ServerPlayer)serverPlayer.elementAt(i);
  //}

  private boolean filled = false;
  private Controller control;
  private ServerConnection conn;
  private GoClient client;
  private MultiBox mb;
  private MultiWindow spcw;

  private urMenuBar menuBar = new urMenuBar(null);
  private menuListener mListen = new menuListener();

  // Menu items to be attached to MultiWindow
  private Menu viewMenu = menuBar.generate("View");
  private MenuItem refreshItem = mListen.generate(viewMenu, "Refresh",
						  new MenuShortcut(KeyEvent.VK_R));
  private MenuItem refreshaItem
    = mListen.generateWithSep(viewMenu, "Refresh All",
			      new MenuShortcut(KeyEvent.VK_R, true));
  private MenuItem closeItem = mListen.generate(viewMenu, "Close",
						new MenuShortcut(KeyEvent.VK_W));

  private MenuItem matchItem = new MenuItem("Match...");
  private MenuItem observeItem = new MenuItem("Observe");
  private MenuItem unobserveItem = new MenuItem("Unobserve");
  private MenuItem statsItem = new MenuItem("Stats");
  private MenuItem resultsItem = new MenuItem("Results");
  private MenuItem rresultsItem = new MenuItem("Rated Results");

  private PopupMenu matchpm = new PopupMenu("Options");

  private String spcvisibleString = "Who View Lines";
  private String spcposString = "Who View Position";
  public String spcsortString = "Who View Sort";

  private Optionizer opser = Ergo.opser;

  public ServerPlayerContainer (Controller cn1, ServerConnection conn, GoClient client) {
    control = cn1;
    this.conn = conn;
    this.client = client;
    String b = "";
    String l = "l";
    String[] formatw = {l, l, l, l, l, l};
    String[] headingsw = {"Player Name", "Rank", "Idle", "Info", "Playing", "Observing"};
    String[] widtherw  = {"WWWWWWWWWW", b, "99m", "QX", b, b};

    opser.expressOwnership(spcvisibleString, Optionizer.TYPE_INTEGER, null, 
			   new Integer(25));
    opser.expressOwnership(spcsortString, Optionizer.TYPE_INTEGER, null,
			   new Integer(SORT_RANK));
    opser.expressOwnership(opser.savingString, Optionizer.TYPE_BOOLEAN, this,
			   new Boolean(true)); // get vislines as saving.

    TextColorManager.expressAll(this, 4);
   
    opser.expressOwnership(GlobalOptions.infofontString, Optionizer.TYPE_FONT, this, null);

    int sortMethod = opser.getIntegerOption(spcsortString);
    try {
      mb = new MultiBox(this, formatw, widtherw, headingsw, 
			opser.getIntegerOption(spcvisibleString), sortMethod) ;
    }
    catch (Exception e) {
      Debug.backtrace(e);
    }
    spcw = new MultiWindow(this, mb, sortMethod);
    Object o = new PositionListener(spcposString, spcw, new Point(500, 100), opser);
    
    TerminalWindow.registrar.registerWindowsMenuCommand(spcw);
    mb.add(matchpm);
    mb.setColorVec(TextColorManager.getColorVec());
    mb.setFont(opser.getFontOption(GlobalOptions.infofontString));

    menuBar.add(spcw.getSortMenu());
    menuBar.add(TerminalWindow.registrar.registerMenu(new Menu("Window"), spcw));
 
    spcw.setMenuBar(menuBar); 
  }

  public String[] sortMethods() { return sortMethods; }
  public int defaultSortMethod() { return SORT_RANK; }
  public String windowName() { return conn.toString() + " - Who View"; }
  public String menuString() { return "Who View"; }
  public MenuShortcut menuShortcut () {
    return new MenuShortcut(KeyEvent.VK_H);
  }
  public int menuPriority() { return 102; }
  public void menuSelect(Frame f) {
    if (filled == false) {
      filled = true;
      conn.send("who", false);
    }
    else {
      spcw.setVisible(true);
      spcw.toFront();
    }
  }

  public Class appliesTo () { return null; }

  public void winDestroyed() {	// not really destroyed. just sent away somewhere.
    filled = false;
    //    control.window.registrar.deregisterWindowsMenuCommand(spcw);
  }

  public void optionEvent(String arg, Object value) {
    if (opser.isSameKey(opser.savingString, arg)) {
      opser.updateOption(spcvisibleString, new Integer(mb.visLines()));
    }
    else if (TextColorManager.isColorString(arg)) {
      mb.setColorVec(TextColorManager.getColorVec());
    }
    else if (opser.isSameKey(arg, GlobalOptions.infofontString)) {
      mb.setFont(opser.getFontOption(GlobalOptions.infofontString));
      spcw.pack();		// interesting attempt.
    }

  } 

  ServerPlayer stashedUseful;	// store this between invokations of
  // eventOn and actionOn.
  public int eventOn(Object theUseful, MouseEvent e, int field) {
    ServerPlayer sp = (ServerPlayer)theUseful;
    if (e.getID() == MouseEvent.MOUSE_PRESSED) {
      if (e.isMetaDown()) {
        matchpm.removeAll();
        if (sp.flags.indexOf('X') == -1 && sp.playing.equals("--"))
	  matchpm.add(matchItem);
        if (!sp.playing.equals("--")) { // add extra items for observation.
          int observenumber = Integer.parseInt(sp.playing);
          GameWindow gw = client.getGameWindowByNumber(observenumber);
          if (gw == null) 
            matchpm.add(observeItem);
          else
            matchpm.add(unobserveItem);
	}
        matchpm.add(statsItem);
        matchpm.add(resultsItem);
        if (conn.server.isNNGStype()) 
	  matchpm.add(rresultsItem);
	matchpm.show(mb.listCanvas, e.getX(), e.getY());
      }				// end if metaDown();
    }
    stashedUseful = sp;
    //    System.out.println("Event "+e+" received on player "+sp+", field "+field);
    return 0;
  }

  public class menuListener extends urMenuListener {
  public void itemSelected(MenuItem source) {
    if (source == refreshItem) {
      conn.send("who", false); // this should make use of stashed parameters.
    }
    else if (source == refreshaItem) {
      conn.send("who", false);
    }
    else if (source == closeItem) {
      // see SGC.
      spcw.destroyed();
    }
  }
}

  public boolean actionOn(Event e, Object arg) {
    if (e.target == matchItem) {
      MatchDialog md = new MatchDialog(spcw, false);
      md.setOpponent(stashedUseful.name);
      md.show();
    }
    else if (e.target == observeItem) {
      if (!stashedUseful.playing.equals("--")) {
        int observenumber = Integer.parseInt(stashedUseful.playing);
        conn.send("observe " + observenumber);
      }
    }
    else if (e.target == unobserveItem) {
      if (!stashedUseful.playing.equals("--")) {
        int observenumber = Integer.parseInt(stashedUseful.playing);
        conn.send("unobserve " + observenumber);
      }
    }
    else if (e.target == statsItem) {
      conn.send("stats " + stashedUseful.name, false);
    }
    else if (e.target == resultsItem) {
      conn.send("results " + stashedUseful.name, false);
    }
    else if (e.target == rresultsItem) {
      conn.send("rresults " + stashedUseful.name, false);
    }
    return true;
  }

  public Enumeration Players() {
    return serverPlayer.elements();
  }
  public ServerPlayer nextPlayer(Enumeration e) {
    return (ServerPlayer)e.nextElement();
  }
  public ServerPlayer byName(String name) {
    return (ServerPlayer)serverPlayer.get(name);
  }

  public int compare(int method, Object o1, Object o2) {
    ServerPlayer s1 = (ServerPlayer) o1;
    ServerPlayer s2 = (ServerPlayer) o2;
    switch(method) {
    case SORT_NAME:
      return s1.name.toLowerCase().compareTo(s2.name.toLowerCase());
    case SORT_RANK:
      return s1.rank.compareTo(s2.rank);
    }
    return 0;
  }
  public void addPlayer(ServerPlayer sp, boolean quietness) {
    serverPlayer.put(sp.name, sp);
    mb.insertEntry(sp, sp.render(), quietness);
  }
  public void updatePlayer(ServerPlayer sp, boolean quietness) {
    mb.updateEntry(sp, sp.render());
  }
  public void removePlayer(ServerPlayer sp, boolean quietness) {
    if (sp == null) return;
    serverPlayer.remove(sp.name);
    mb.removeEntry(sp, quietness);
    //    System.out.println("Hash now "+serverPlayer.size()+" elements");
  }
  public void clear() {
    for (Enumeration e = Players(); e.hasMoreElements(); ) {
      removePlayer(nextPlayer(e), true);
    }
  }
  public void destroy() {
    clear();
    TerminalWindow.registrar.deregisterWindowsMenuCommand(spcw);
    spcw.dispose();
  }
  public void update() {
    mb.refresh();
  }
  public void show() {
    spcw.show();
  }
  public void setSort(int sortm) {
    mb.reSort(sortm);
    mb.refresh();
  }
  public void apply(String flags, String observe, String play, String name,
		    String idle, String rank, boolean quietness) {    
    ServerPlayer corresp;
    try {
      if ((corresp = byName(name))==null) {
        corresp = new ServerPlayer();
        corresp.imbue(flags, observe, play, name, idle, rank);
        addPlayer(corresp, quietness);
      }
      else {
        corresp.imbue(flags, observe, play, name, idle, rank);
        updatePlayer(corresp, quietness);
      }
    }
    catch (ParseException e) {
      Debug.backtrace(e);
    }
  }
  public void apply(String name, String rank) {
    ServerPlayer corresp;
    try {
      if ((corresp = byName(name)) == null) {
        corresp = new ServerPlayer();
        corresp.imbue(name, rank);
        addPlayer(corresp, false);
      }
      // if we knew the player already, we are unlikely to have learned anything
      // about them through this message....!
    }
    catch (ParseException e) {
      Debug.backtrace(e);
    }
  }
/*  public static void main(String[] argv) {
    ServerPlayerContainer spc = new ServerPlayerContainer();
    String b="";
    String l="l";
    String[] format={l,l,l,l,l,l};
    String[] headings={"Player Name", "Rank", "Idle", "Info", "Playing", "Observing"};
    String[] widther={"WWWWWWWWWW",b,"99m","QX",b,b};
    try {
      MultiBox testMB=new MultiBox(spc, format, widther, headings, SORT_NAME);
      SPCWindow spcw=new SPCWindow(testMB);
      }
    catch (Exception e) {
      e.printStackTrace(System.out);
      }
    }*/
} // end class ServerPlayerContainer