gt:     return new Class<?>[0];
context: /*
   * $Id$
   *
   * Copyright (c) 2005 by Rodney Kinney
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
   * License (LGPL) as published by the Free Software Foundation.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Library General Public License for more details.
   *
   * You should have received a copy of the GNU Library General Public
   * License along with this library; if not, copies are available
   * at http://www.opensource.org.
   */
  package VASSAL.build.module.map;
  
  import java.awt.Color;
  import java.awt.Graphics;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.util.HashMap;
  
  import VASSAL.build.AbstractConfigurable;
  import VASSAL.build.Buildable;
  import VASSAL.build.GameModule;
  import VASSAL.build.module.GameComponent;
  import VASSAL.build.module.Map;
  import VASSAL.build.module.documentation.HelpFile;
  import VASSAL.command.Command;
  import VASSAL.configure.ColorConfigurer;
  import VASSAL.configure.SingleChildInstance;
  import VASSAL.counters.ColoredBorder;
  import VASSAL.counters.GamePiece;
  import VASSAL.counters.Stack;
  import VASSAL.i18n.Resources;
  
  public class HighlightLastMoved extends AbstractConfigurable implements Drawable, MouseListener, GameComponent {
    public static final String ENABLED = "enabled";
    public static final String COLOR = "color";
    public static final String THICKNESS = "thickness";
  
    protected ColoredBorder highlighter;
    protected GamePiece lastMoved;
    protected static java.util.Map<Map,HighlightLastMoved> instances =
      new HashMap<Map,HighlightLastMoved>();
  
    protected boolean enabled;
    protected boolean currentlyEnabled;
  
    public HighlightLastMoved() {
      highlighter = new ColoredBorder(Color.RED, 2);
      enabled = true;
    }
  
    public String[] getAttributeDescriptions() {
      return new String[]{
          Resources.getString("Editor.HighlightLastMoved.enabled"), //$NON-NLS-1$
          Resources.getString(Resources.COLOR_LABEL),
          Resources.getString("Editor.HighlightLastMoved.thickness"), //$NON-NLS-1$
      };
    }
  
    public Class<?>[] getAttributeTypes() {
      return new Class<?>[]{
        Boolean.class,
        Color.class,
        Integer.class
      };
    }
  
    public String[] getAttributeNames() {
      return new String[]{
        ENABLED,
        COLOR,
        THICKNESS
      };
    }
  
    public void setAttribute(String key, Object value) {
      if (COLOR.equals(key)) {
        if (value instanceof String) {
          value = ColorConfigurer.stringToColor((String) value);
        }
        highlighter.setColor((Color) value);
      }
      else if (THICKNESS.equals(key)) {
        if (value instanceof String) {
          value = Integer.valueOf((String) value);
        }
        highlighter.setThickness(((Integer) value).intValue());
      }
      else if (ENABLED.equals(key)) {
        if (value instanceof String) {
          value = Boolean.valueOf((String) value);
        }
        enabled = ((Boolean) value).booleanValue();
      }
    }
  
    public String getAttributeValueString(String key) {
      if (COLOR.equals(key)) {
        return ColorConfigurer.colorToString(highlighter.getColor());
      }
      else if (THICKNESS.equals(key)) {
        return String.valueOf(highlighter.getThickness());
      }
      else if (ENABLED.equals(key)) {
        return String.valueOf(enabled);
      }
      else {
        return null;
      }
    }
  
    public void addTo(Buildable parent) {
      Map map = (Map) parent;
      map.addDrawComponent(this);
      map.addLocalMouseListener(this);
      GameModule.getGameModule().getGameState().addGameComponent(this);
      instances.put(map, this);
      validator = new SingleChildInstance(map, getClass());
    }
  
    public void removeFrom(Buildable parent) {
      Map map = (Map) parent;
      map.removeDrawComponent(this);
      map.removeLocalMouseListener(this);
      GameModule.getGameModule().getGameState().removeGameComponent(this);
      instances.remove(map);
    }
  
    public void draw(Graphics g, Map map) {
      if (lastMoved != null && enabled) {
        if (lastMoved.getMap() == map) {
          highlighter.draw(lastMoved, g, (int) (lastMoved.getPosition().x * map.getZoom()),
              (int) (lastMoved.getPosition().y * map.getZoom()), map.getView(), map.getZoom());
        }
        else {
          lastMoved = null;
        }
      }
    }
  
    public void setup(boolean gameStarting) {
      currentlyEnabled = gameStarting && enabled;
      lastMoved = null;
    }
  
    public Command getRestoreCommand() {
      return null;
    }
  
    public static void setLastMoved(GamePiece p) {
      HighlightLastMoved h = instances.get(p.getMap());
      if (h != null) {
        h.setLastMovedPiece(p);
      }
    }
  
    public void setLastMovedPiece(GamePiece p) {
      if (currentlyEnabled) {
        if (p.getParent() instanceof Stack) {
          lastMoved = p.getParent();
        }
        else {
          lastMoved = p;
        }
        if (lastMoved.getMap() != null) {
          lastMoved.getMap().getPieceCollection().moveToFront(lastMoved);
        }
      }
    }
  
    public boolean drawAboveCounters() {
      return true;
    }
  
    public void mouseClicked(MouseEvent e) {
    }
  
    public void mousePressed(MouseEvent e) {
    }
  
    public void mouseReleased(MouseEvent e) {
      lastMoved = null;
    }
  
    public void mouseEntered(MouseEvent e) {
    }
  
    public void mouseExited(MouseEvent e) {
    }
  
    public HelpFile getHelpFile() {
      return HelpFile.getReferenceManualPage("Map.htm", "LastMoveHighlighter");
    }
  
    public static String getConfigureTypeName() {
      return Resources.getString("Editor.HighlightLastMoved.component_type"); //$NON-NLS-1$
    }
  
    public Class<?>[] getAllowableConfigureComponents() {
  