Changeset 3dd6a9e


Ignore:
Timestamp:
Aug 16, 2010, 8:01:55 PM (7 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
f429dec
Parents:
035908f
Message:

gui.swing:
Fixed a bug that caused an exception on start;
APMPlot accepts a list of players instead of an array;
Improved renderer architecture;
Added javadoc comments
sc2replay:
The players' realID is displayed as tooltip of the player renderer components

Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/APMPlot.java

    r035908f r3dd6a9e  
    6767        private ActionFilter actionFilter;
    6868
    69         public APMPlot(Player... players) {
     69        public APMPlot(List<? extends Player> players) {
    7070                super(new BorderLayout());
    7171
     
    7373
    7474                // For each of the specified players
    75                 for (int playerIndex = 0; playerIndex < players.length; playerIndex++) {
    76                         Player player = players[playerIndex];
     75                for (int playerIndex = 0; playerIndex < players.size(); playerIndex++) {
     76                        Player player = players.get(playerIndex);
    7777                        List<? extends GameAction> actions = player.getActions();
    7878                        if (actions.isEmpty()) {
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/ReplayParserGUI.java

    r035908f r3dd6a9e  
    195195                logoFileNames.add("icons/logo16.png");
    196196                logoFileNames.add("icons/logo32.png");
    197                 logoFileNames.add("icons/logo64.png");
    198197                List<Image> icons = new LinkedList<Image>();
    199198                for (String logoFileName : logoFileNames) {
     
    429428                                else if (selectionIndex == 1) {
    430429                                        if (infoDisplay.getComponentAt(1) == null && selectedReplay != null) {
    431                                                 Player[] players = new Player[selectedReplay.getPlayerCount()];
    432                                                 selectedReplay.getPlayers().toArray(players);
     430                                                List<? extends Player> players = selectedReplay.getPlayers();
    433431                                                Component apmRendererComp = apmRenderer.getRendererComponent(players);
    434432                                                apmRendererComp.setMinimumSize(new Dimension(0, 0));
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/renderers/APMRenderer.java

    r035908f r3dd6a9e  
    2424import java.awt.BorderLayout;
    2525import java.awt.Component;
     26import java.util.List;
    2627
    2728import javax.swing.Box;
     
    3132import de.erichseifert.warp.core.replay.Player;
    3233import de.erichseifert.warp.gui.swing.APMPlot;
     34import de.erichseifert.warp.gui.swing.ItemRenderer;
    3335import de.erichseifert.warp.gui.swing.VisibilityChangeEvent;
    3436import de.erichseifert.warp.gui.swing.VisibilityChangeListener;
    3537
    36 public class APMRenderer {
     38/**
     39 * Class that represents a renderer for multiple players, displaying their
     40 * actions per minute in a plot.
     41 */
     42public class APMRenderer implements ItemRenderer<List<? extends Player>> {
    3743
    38         private static class APMRendererComponent extends JPanel implements VisibilityChangeListener<Player> {
     44        /**
     45         * Class that represents a component displaying the actions per minute
     46         * of multiple players.
     47         */
     48        protected static class APMRendererComponent extends JPanel implements VisibilityChangeListener<Player> {
    3949                private final DefaultPlayerRenderer<Player> playerRenderer;
    4050                private final APMPlot plot;
    4151
    42                 public APMRendererComponent(Player... players) {
     52                /**
     53                 * Creates an <code>APMRendererComponent</code> displaying the specified players.
     54                 * @param players Players to be rendered.
     55                 */
     56                public APMRendererComponent(List<? extends Player> players) {
    4357                        super(new BorderLayout());
    4458
     
    6680        }
    6781
     82        /**
     83         * Creates an <code>APMRenderer</code> object.
     84         */
    6885        public APMRenderer() {
    6986        }
    7087
    71         public Component getRendererComponent(Player... players) {
     88        @Override
     89        public Component getRendererComponent(List<? extends Player> players) {
    7290                return new APMRendererComponent(players);
    7391        }
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/renderers/DefaultChatRenderer.java

    r035908f r3dd6a9e  
    4343        private final Map<T, Boolean> playerVisibility;
    4444
    45         protected class DefaultChatComponent extends JPanel {
     45        protected static class DefaultChatComponent extends JPanel {
    4646                private final JEditorPane messageDisplay;
    4747
    48                 protected DefaultChatComponent(Collection<? extends Player> players) {
     48                public DefaultChatComponent(Collection<? extends Player> players, Map<? extends Player, Boolean> playerVisibility) {
    4949                        super(new BorderLayout());
    5050
     
    7777                        messageDisplay.setText(chatLogString);
    7878                }
     79
     80                private static String messageToHTML(Player player, ChatMessage message) {
     81                        String playerName = player.getName();
     82                        Color playerColor= player.getColor();
     83                        String colorHex = GUIUtil.toHTMLColor(playerColor);
     84                        String channel;
     85                        if (message.getChannel() == ChatMessage.ALL) {
     86                                channel = "All";
     87                        }
     88                        else if (message.getChannel() == ChatMessage.TEAM) {
     89                                channel = "Team";
     90                        }
     91                        else if (message.getChannel() == ChatMessage.OBSERVERS) {
     92                                channel = "Observers";
     93                        }
     94                        else {
     95                                channel = String.valueOf(message.getChannel());
     96                        }
     97                        String messageString = message.getMessage();
     98                        String playerHTML = String.format("<font color=\"%s\"><strong>%s</strong></font> [%s]: %s <br />", colorHex, playerName, channel, messageString);
     99
     100                        return playerHTML;
     101                }
    79102        }
    80103
     
    83106        }
    84107
    85         private String messageToHTML(Player player, ChatMessage message) {
    86                 String playerName = player.getName();
    87                 Color playerColor= player.getColor();
    88                 String colorHex = GUIUtil.toHTMLColor(playerColor);
    89                 String channel;
    90                 if (message.getChannel() == ChatMessage.ALL) {
    91                         channel = "All";
    92                 }
    93                 else if (message.getChannel() == ChatMessage.TEAM) {
    94                         channel = "Team";
    95                 }
    96                 else if (message.getChannel() == ChatMessage.OBSERVERS) {
    97                         channel = "Observers";
    98                 }
    99                 else {
    100                         channel = String.valueOf(message.getChannel());
    101                 }
    102                 String messageString = message.getMessage();
    103                 String playerHTML = String.format("<font color=\"%s\"><strong>%s</strong></font> [%s]: %s <br />", colorHex, playerName, channel, messageString);
    104 
    105                 return playerHTML;
    106         }
    107 
    108108        @Override
    109109        public Component getRendererComponent(Collection<? extends Player> value) {
    110                 return new DefaultChatComponent(value);
     110                return new DefaultChatComponent(value, playerVisibility);
    111111        }
    112112
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/renderers/DefaultPlayerRenderer.java

    r035908f r3dd6a9e  
    4343
    4444import de.erichseifert.warp.core.replay.Player;
    45 import de.erichseifert.warp.core.util.GUIUtil;
    4645import de.erichseifert.warp.gui.swing.ItemRenderer;
    4746import de.erichseifert.warp.gui.swing.VisibilityChangeEvent;
     
    5251        private final Map<T, Boolean> playerVisibility;
    5352
    54         protected class DefaultPlayerComponent extends JPanel {
     53        protected static class DefaultPlayerComponent<T extends Player> extends JPanel {
     54                private final Set<VisibilityChangeListener<T>> listeners;
    5555                private final T player;
    5656                private final JCheckBox visiblityBox;
     
    5858                private final Shape colorShape;
    5959
    60                 public DefaultPlayerComponent(T player) {
     60                public DefaultPlayerComponent(T player, boolean visible) {
    6161                        super(new FlowLayout(FlowLayout.LEADING));
    6262                        this.player = player;
    6363
     64                        listeners = new HashSet<VisibilityChangeListener<T>>();
     65
    6466                        visiblityBox = new JCheckBox();
    65                         boolean selected = playerVisibility.containsKey(player) ? playerVisibility.get(player) : true;
    66                         visiblityBox.setSelected(selected);
     67                        visiblityBox.setSelected(visible);
    6768                        visiblityBox.addChangeListener(new ChangeListener() {
    6869                                @Override
     
    7475
    7576                        playerLabel = new JLabel();
    76                         playerLabel.setToolTipText(GUIUtil.toHTMLColor(player.getColor()));
    7777                        playerLabel.addMouseListener(new MouseAdapter() {
    7878                                @Override
     
    104104                        }
    105105                }
     106
     107                protected void fireVisibilityChanged(T player, boolean visible) {
     108                        VisibilityChangeEvent<T> event = new VisibilityChangeEvent<T>(player, visible);
     109                        for (VisibilityChangeListener<T> listener : listeners) {
     110                                listener.visibilityChanged(event);
     111                        }
     112                }
     113
     114                protected void setListeners(Set<VisibilityChangeListener<T>> listeners) {
     115                        this.listeners.clear();
     116                        if (listeners != null) {
     117                                this.listeners.addAll(listeners);
     118                        }
     119                }
     120
     121                @Override
     122                public void setToolTipText(String text) {
     123                        super.setToolTipText(text);
     124                        playerLabel.setToolTipText(text);
     125                }
    106126        }
    107127
     
    119139        @Override
    120140        public Component getRendererComponent(T value) {
    121                 return new DefaultPlayerComponent(value);
     141                boolean visible = playerVisibility.containsKey(value) ? playerVisibility.get(value) : true;
     142                DefaultPlayerComponent<T> comp = new DefaultPlayerComponent(value, visible);
     143                comp.setListeners(listeners);
     144                return comp;
    122145        }
    123146
     
    129152                listeners.remove(listener);
    130153        }
    131 
    132         protected void fireVisibilityChanged(T player, boolean visible) {
    133                 VisibilityChangeEvent<T> event = new VisibilityChangeEvent<T>(player, visible);
    134                 for (VisibilityChangeListener<T> listener : listeners) {
    135                         listener.visibilityChanged(event);
    136                 }
    137         }
    138154}
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/renderers/DefaultReplayRenderer.java

    r035908f r3dd6a9e  
    3838import de.erichseifert.warp.gui.swing.VisibilityChangeListener;
    3939
     40/**
     41 * Class that represents a renderer for <code>Replay</code> objects.
     42 * This renderer consists of a player renderer and a chat log renderer,
     43 * whose outputs are arranged and managed by <code>DefaultReplayComponent</code>.
     44 *
     45 * This class can be subclassed in order to customize the individual
     46 * components.
     47 * @param <T> Type of the replay object to be rendered.
     48 */
    4049public class DefaultReplayRenderer<T extends Replay> implements ItemRenderer<T> {
    41         protected final DefaultPlayerRenderer<Player> playerRenderer;
    42         protected final DefaultChatRenderer<Player> chatRenderer;
     50        private final Map<T, Component> componentCache;
    4351
    44         protected final Map<T, Component> componentCache;
     52        private DefaultPlayerRenderer<Player> playerRenderer;
     53        private DefaultChatRenderer<Player> chatRenderer;
    4554
    46         protected class DefaultReplayComponent extends JPanel {
     55        /**
     56         * Class that represents the default component for displaying a replay.
     57         */
     58        protected static class DefaultReplayComponent<T extends Replay> extends JPanel {
     59                private final DefaultPlayerRenderer<Player> playerRenderer;
     60                private final DefaultChatRenderer<Player> chatRenderer;
    4761                private final T replay;
    4862                private final JPanel topHalf;
     
    5266                private Component chatComponent;
    5367
    54                 protected DefaultReplayComponent(T replay) {
     68                /**
     69                 * Creates a <code>DefaultReplayComponent</code> object displaying
     70                 * the specified replay and using the specified renderers.
     71                 * @param replay Replay to be displayed.
     72                 * @param playerRenderer Player renderer.
     73                 * @param chatRenderer Chat renderer.
     74                 */
     75                public DefaultReplayComponent(T replay, DefaultPlayerRenderer<Player> playerRenderer, DefaultChatRenderer<Player> chatRenderer) {
    5576                        super(new GridLayout(2, 1));
    5677                        this.replay = replay;
     78                        this.playerRenderer = playerRenderer;
     79                        this.chatRenderer = chatRenderer;
    5780                        setBorder(new EmptyBorder(5, 5, 5, 5));
    5881
     
    7093                        }
    7194                        else {
     95                                playerRenderer.addVisibilityChangeListener(new VisibilityChangeListener<Player>() {
     96                                        @Override
     97                                        public void visibilityChanged(VisibilityChangeEvent<Player> event) {
     98                                                DefaultReplayComponent.this.chatRenderer.setPlayerVisible(event.getSource(), event.isVisible());
     99                                                // Update chat component
     100                                                bottomHalf.remove(chatComponent);
     101                                                chatComponent = DefaultReplayComponent.this.chatRenderer.getRendererComponent(DefaultReplayComponent.this.replay.getPlayers());
     102                                                bottomHalf.add(chatComponent, BorderLayout.CENTER);
     103                                                bottomHalf.revalidate();
     104                                        }
     105                                });
     106
    72107                                // FIXME: Handle unsingned value
    73108                                replayDescription.setText("Duration: "+gameDurationToString(replay.getDescriptor().getDuration())+" minutes");
     
    82117                        bottomHalf.add(playerPanel, BorderLayout.NORTH);
    83118                        bottomHalf.add(chatComponent, BorderLayout.CENTER);
    84 
    85                         playerRenderer.addVisibilityChangeListener(new VisibilityChangeListener<Player>() {
    86                                 @Override
    87                                 public void visibilityChanged(VisibilityChangeEvent<Player> event) {
    88                                         bottomHalf.remove(chatComponent);
    89                                         chatRenderer.setPlayerVisible(event.getSource(), event.isVisible());
    90                                         chatComponent = chatRenderer.getRendererComponent(DefaultReplayComponent.this.replay.getPlayers());
    91                                         bottomHalf.add(chatComponent, BorderLayout.CENTER);
    92                                         bottomHalf.revalidate();
    93                                 }
    94                         });
    95119                }
    96120        }
    97121
     122        /**
     123         * Creates a <code>DefaultReplayRenderer</code> object.
     124         */
    98125        public DefaultReplayRenderer() {
    99126                playerRenderer = new DefaultPlayerRenderer<Player>();
     
    106133                Component comp = componentCache.get(value);
    107134                if (comp == null) {
    108                         comp = new DefaultReplayComponent(value);
     135                        comp = new DefaultReplayComponent(value, playerRenderer, chatRenderer);
    109136                        componentCache.put(value, comp);
    110137                }
     
    112139        }
    113140
     141        /**
     142         * Converts the duration of a replay into a string.
     143         * @param duration Duration in seconds.
     144         * @return String duration.
     145         */
    114146        protected static String gameDurationToString(int duration) {
    115                 int mins = (int) (duration / 120);
    116                 int secs = (duration - mins*120) / 2;
     147                int mins = (int) (duration / 60);
     148                int secs = duration - mins*60;
    117149                return String.format("%d:%02d", mins, secs);
    118150        }
     151
     152        /**
     153         * Returns the currently used player renderer.
     154         * @return Player renderer.
     155         */
     156        protected DefaultPlayerRenderer<Player> getPlayerRenderer() {
     157                return playerRenderer;
     158        }
     159
     160        /**
     161         * Sets the currently used player renderer to the specified value.
     162         * @param playerRenderer Player renderer.
     163         */
     164        protected void setPlayerRenderer(DefaultPlayerRenderer<? extends Player> playerRenderer) {
     165                this.playerRenderer = (DefaultPlayerRenderer<Player>) playerRenderer;
     166        }
     167
     168        /**
     169         * Returns a map used to cache the component for a single replay.
     170         * @return Cache.
     171         */
     172        protected Map<T, Component> getComponentCache() {
     173                return componentCache;
     174        }
     175
     176        /**
     177         * Returns the currently used chat renderer.
     178         * @return Chat renderer.
     179         */
     180        protected DefaultChatRenderer<Player> getChatRenderer() {
     181                return chatRenderer;
     182        }
     183
     184        /**
     185         * Sets the currently used chat renderer to the specified value.
     186         * @param chatRenderer Chat renderer.
     187         */
     188        protected void setChatRenderer(DefaultChatRenderer<Player> chatRenderer) {
     189                this.chatRenderer = chatRenderer;
     190        }
    119191}
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/renderers/SC2ReplayRenderer.java

    r035908f r3dd6a9e  
    3939public class SC2ReplayRenderer extends DefaultReplayRenderer<SC2Replay> {
    4040
    41         protected class SC2ReplayComponent extends JPanel {
     41        private class SC2ReplayComponent extends JPanel {
    4242                private final SC2Replay replay;
    4343                private final JPanel topHalf;
     
    4848                private Component chatComponent;
    4949
    50                 protected SC2ReplayComponent(SC2Replay replay) {
     50                private SC2ReplayComponent(SC2Replay replay) {
    5151                        super(new GridLayout(2, 1));
    5252                        this.replay = replay;
     
    6868                        if (replay == null) {
    6969                                playerPanel = new JPanel();
    70                                 chatComponent = chatRenderer.getRendererComponent(null);
     70                                chatComponent = getChatRenderer().getRendererComponent(null);
    7171                        }
    7272                        else {
     73                                getPlayerRenderer().addVisibilityChangeListener(new VisibilityChangeListener<Player>() {
     74                                        @Override
     75                                        public void visibilityChanged(VisibilityChangeEvent<Player> event) {
     76                                                bottomHalf.remove(chatComponent);
     77                                                getChatRenderer().setPlayerVisible(event.getSource(), event.isVisible());
     78                                                chatComponent = getChatRenderer().getRendererComponent(SC2ReplayComponent.this.replay.getPlayers());
     79                                                bottomHalf.add(chatComponent, BorderLayout.CENTER);
     80                                                bottomHalf.revalidate();
     81                                        }
     82                                });
     83
    7384                                // FIXME: Handle unsingned value
    7485                                replayDescription.setText("Duration: "+gameDurationToString(replay.getDescriptor().getDuration())+" minutes");
     
    7788                                playerPanel = new JPanel(new GridLayout((int) Math.round(replay.getPlayerCount()/2.0), 2));
    7889                                for (Player player : replay.getPlayers()) {
    79                                         playerPanel.add(playerRenderer.getRendererComponent(player));
     90                                        playerPanel.add(getPlayerRenderer().getRendererComponent(player));
    8091                                }
    8192
    82                                 chatComponent = chatRenderer.getRendererComponent(replay.getPlayers());
     93                                chatComponent = getChatRenderer().getRendererComponent(replay.getPlayers());
    8394                        }
    8495                        bottomHalf.add(playerPanel, BorderLayout.NORTH);
    8596                        bottomHalf.add(chatComponent, BorderLayout.CENTER);
    86 
    87                         playerRenderer.addVisibilityChangeListener(new VisibilityChangeListener<Player>() {
    88                                 @Override
    89                                 public void visibilityChanged(VisibilityChangeEvent<Player> event) {
    90                                         bottomHalf.remove(chatComponent);
    91                                         chatRenderer.setPlayerVisible(event.getSource(), event.isVisible());
    92                                         chatComponent = chatRenderer.getRendererComponent(SC2ReplayComponent.this.replay.getPlayers());
    93                                         bottomHalf.add(chatComponent, BorderLayout.CENTER);
    94                                         bottomHalf.revalidate();
    95                                 }
    96                         });
    9797                }
    9898        }
    9999
    100100        public SC2ReplayRenderer() {
     101                setPlayerRenderer(new SC2PlayerRenderer());
    101102        }
    102103
    103104        @Override
    104105        public Component getRendererComponent(SC2Replay value) {
    105                 Component comp = componentCache.get(value);
     106                Component comp = getComponentCache().get(value);
    106107                if (comp == null) {
    107108                        comp = new SC2ReplayComponent((SC2Replay) value);
    108                         componentCache.put(value, comp);
     109                        getComponentCache().put(value, comp);
    109110                }
    110111                return comp;
Note: See TracChangeset for help on using the changeset viewer.