Changeset b1df941


Ignore:
Timestamp:
Aug 3, 2010, 1:24:00 PM (8 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
c4faca2
Parents:
88ead20
Message:

Added "Open replay..." menu item to the popup menu of the replay table;

Added abstract controller class

Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • core/src/main/java/de/erichseifert/warp/core/WARP.java

    r88ead20 rb1df941  
    2222package de.erichseifert.warp.core;
    2323
    24 import java.io.File;
    25 import java.util.Collection;
    26 import java.util.Map;
    27 import java.util.Set;
    28 
    2924import de.erichseifert.warp.core.io.BufferedStorage;
    3025import de.erichseifert.warp.core.io.ReplayStorage;
    3126import de.erichseifert.warp.core.io.SerializingStorage;
    3227import de.erichseifert.warp.core.io.Settings;
    33 import de.erichseifert.warp.core.io.search.ReplayIndexer.SearchMode;
    34 import de.erichseifert.warp.core.io.search.indices.Index.Range;
    35 import de.erichseifert.warp.core.replays.ReplayParserFactory;
    3628import de.erichseifert.warp.core.ui.CLI;
    3729import de.erichseifert.warp.core.ui.WARPUI;
    38 import de.erichseifert.warp.core.util.FileUtil;
    3930
    4031/**
     
    4233 * It coordinates the data model and the user interface.
    4334 */
    44 public class WARP {
    45         private static final int walkDepth = 3;
     35public class WARP extends DataPresenter {
    4636
    47         private final ReplayStorage storage;
    48         private WARPUI ui;
     37        public WARP() {
     38                ReplayStorage storage = new SerializingStorage();
     39                ReplayStorage storageBuffer = new BufferedStorage(storage);
     40                setStorage(storageBuffer);
    4941
    50         /**
    51          * Class that parses all files in a directory and subdirectories.
    52          */
    53         private class ParserThread extends Thread {
    54                 private final File dir;
    55                 private final ProgressListener[] listeners;
    56 
    57                 /**
    58                  * Creates a <code>ParserThread</code> object parsing the
    59                  * specified directory and notfying the specified listeners.
    60                  * This thread also descends into subfolders.
    61                  * @param dir Directory to be searched for parsable files.
    62                  * @param listeners Listeners to be notified.
    63                  */
    64                 public ParserThread(File dir, ProgressListener... listeners) {
    65                         this.dir = dir;
    66                         this.listeners = listeners;
    67                 }
    68 
    69                 @Override
    70                 public void run() {
    71                         Collection<File> replayFiles = FileUtil.walk(dir, walkDepth);
    72 
    73                         int elementsProcessed = 0;
    74                         for (File replayFile : replayFiles) {
    75                                 if (storage.contains(replayFile)) {
    76                                         elementsProcessed++;
    77                                         for (ProgressListener listener : listeners) {
    78                                                 listener.progressUpdated(elementsProcessed, replayFiles.size());
    79                                         }
    80                                         continue;
    81                                 }
    82                                 Replay replay = ReplayParserFactory.getInstance().getReplayParser(replayFile);
    83                                 storage.save(replay);
    84                                 elementsProcessed++;
    85 
    86                                 for (ProgressListener listener : listeners) {
    87                                         listener.progressUpdated(elementsProcessed, replayFiles.size());
    88                                 }
    89                         }
    90 
    91                         Settings.getInstance().setParsingComplete(true);
    92 
    93                         // FIXME: Find better solution
    94                         replayFiles = null;
    95                         System.gc();
    96                 }
    97         }
    98 
    99         /**
    100          * Creates a <code>WARP</code> object.
    101          */
    102         public WARP() {
    103                 this(new BufferedStorage(new SerializingStorage()), new CLI());
    104         }
    105 
    106         public WARP(WARPUI ui) {
    107                 this(new BufferedStorage(new SerializingStorage()), ui);
    108         }
    109 
    110         public WARP(ReplayStorage storage, WARPUI ui) {
    111                 this.storage = storage;
    112                 this.ui = ui;
     42                WARPUI ui = new CLI();
     43                setUi(ui);
    11344
    11445                ui.setReplays(storage.getDescriptors());
     
    12556                new WARP();
    12657        }
    127         /**
    128          * Retrieves all supported replay files in the specified directory,
    129          * parses them, and adds them to the storage.
    130          * Calling this method fires a replay info change.
    131          * @param dir
    132          */
    133         public void parseDir(File dir, ProgressListener listener) {
    134                 if (dir == null) {
    135                         return;
    136                 }
    137 
    138                 String oldDir = Settings.getInstance().getReplayDir();
    139                 if (oldDir != null && !oldDir.equals(dir)) {
    140                         // Clear storage
    141                         storage.clear();
    142                 }
    143 
    144                 // Store selected directory for the next startup
    145                 Settings.getInstance().setReplayDir(dir.getPath());
    146                 Settings.getInstance().setParsingComplete(false);
    147 
    148                 ParserThread parserThread = new ParserThread(dir, listener);
    149                 parserThread.start();
    150         }
    151 
    152         /**
    153          * Returns a parsed replay with the specified file path.
    154          * @param descriptor Descriptor of the replay.
    155          * @return Parsed replay.
    156          */
    157         public Replay getReplay(ReplayDescriptor descriptor) {
    158                 return storage.getReplay(descriptor);
    159         }
    160 
    161         /**
    162          * Removes the replay with the specified id from the storage.
    163          * @param id Id of the replay.
    164          */
    165         public void remove(long id) {
    166                 storage.delete(id);
    167         }
    168 
    169         /**
    170          * Returns all replays that match the specified queries and the
    171          * according ranges in the specified search mode.
    172          * @param queries Queries to be searched for.
    173          * @param ranges Ranges of the queries.
    174          * @param mode Search mode.
    175          * @return Search results.
    176          */
    177         public Set<ReplayDescriptor> search(Map<String, Object> query, Map<String, Range> ranges, SearchMode mode) {
    178                 return storage.search(query, ranges, mode);
    179         }
    180 
    181         /**
    182          * Returns the names of all search indices.
    183          * @return Index names.
    184          */
    185         public Set<String> getIndexNames() {
    186                 return storage.getIndexNames();
    187         }
    188 
    189         /**
    190          * Registers the specified listener.
    191          * @param listener ReplayDataChangeListener.
    192          */
    193         public void addDataChangeListener(ReplayDataChangeListener listener) {
    194                 storage.addReplayDataChangeListener(listener);
    195         }
    196 
    197         /**
    198          * Unregisters the specified listener.
    199          * @param listener ReplayDataChangeListener.
    200          */
    201         public void removeDataChangeListener(ReplayDataChangeListener listener) {
    202                 storage.removeReplayDataChangeListener(listener);
    203         }
    204 
    205         public void setUi(WARPUI ui) {
    206                 // TODO Dispose old UI
    207                 this.ui = ui;
    208         }
    20958}
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/ReplayParserGUI.java

    r88ead20 rb1df941  
    8080import javax.swing.table.TableRowSorter;
    8181
     82import de.erichseifert.warp.core.DataPresenter;
    8283import de.erichseifert.warp.core.Player;
    8384import de.erichseifert.warp.core.ProgressListener;
     
    8687import de.erichseifert.warp.core.ReplayDataChangeListener;
    8788import de.erichseifert.warp.core.ReplayDescriptor;
    88 import de.erichseifert.warp.core.WARP;
    8989import de.erichseifert.warp.core.ReplayChangeEvent.EventType;
    9090import de.erichseifert.warp.core.io.Settings;
     
    197197        }
    198198
    199         private final WARP warp;
     199        private final DataPresenter presenter;
    200200
    201201        private final Action openAction;
     
    209209        private final DefaultTableModel replayTableModel;
    210210        private final JTable replayTable;
     211        private final JPopupMenu replayTablePopup;
    211212        private final ReplayCellEditor replayCellEditor;
    212213        private final TableRowSorter<TableModel> replayTableSorter;
     
    221222         * Creates a new <code>ReplayParserGUI</code> object with the default options.
    222223         */
    223         public ReplayParserGUI(WARP warp) {
     224        public ReplayParserGUI(DataPresenter presenter) {
    224225                super("WARP");
    225226
     
    232233                }
    233234
    234                 this.warp = warp;
    235                 warp.addDataChangeListener(this);
     235                this.presenter = presenter;
     236                presenter.addDataChangeListener(this);
    236237
    237238                setDefaultCloseOperation(EXIT_ON_CLOSE);
     
    252253                                        File dir = fileChooser.getSelectedFile();
    253254                                        replayTableModel.setRowCount(0);
    254                                         ReplayParserGUI.this.warp.parseDir(dir, ReplayParserGUI.this);
     255                                        ReplayParserGUI.this.presenter.parseDir(dir, ReplayParserGUI.this);
    255256                                        parsedDir = dir;
    256257                                }
     
    315316                                        int row = replayTable.getSelectedRow();
    316317                                        ReplayDescriptor descriptor = (ReplayDescriptor) replayTable.getValueAt(row, 0);
    317                                         ReplayParserGUI.this.warp.remove(descriptor.getId());
     318                                        ReplayParserGUI.this.presenter.remove(descriptor.getId());
    318319                                        if (removeReplayFromFS.isSelected()) {
    319320                                                descriptor.getFile().delete();
     
    323324                        }
    324325                };
    325                 deleteReplay.putValue(Action.NAME, "Delete replay");
     326                deleteReplay.putValue(Action.NAME, "Delete replay...");
     327
     328                Action openReplay = new AbstractAction() {
     329                        @Override
     330                        public void actionPerformed(ActionEvent e) {
     331                                int row = replayTable.getSelectedRow();
     332                                ReplayDescriptor descriptor = (ReplayDescriptor) replayTable.getValueAt(row, 0);
     333                                File replayFile = descriptor.getFile();
     334                                try {
     335                                        Desktop.getDesktop().open(replayFile);
     336                                } catch (IOException e1) {
     337                                        e1.printStackTrace();
     338                                        Object[] message = new Object[] {
     339                                                "An error occured when trying to open the selected replay file.",
     340                                                "This error can have two reasons:",
     341                                                "- The application associated with this replay file could not be started or",
     342                                                "- There is no application specified for this replay format."
     343                                        };
     344                                        JOptionPane.showMessageDialog(ReplayParserGUI.this, message, "Replay could not be started", JOptionPane.ERROR_MESSAGE);
     345                                }
     346                        }
     347                };
     348                if (!Desktop.isDesktopSupported() || !Desktop.getDesktop().isSupported(Desktop.Action.OPEN)) {
     349                        openReplay.setEnabled(false);
     350                }
     351                openReplay.putValue(Action.NAME, "Open replay...");
    326352
    327353                // Menu bar
     
    393419                                queries.put(indexName, searchValue);
    394420
    395                                 Set<ReplayDescriptor> searchResults = ReplayParserGUI.this.warp.search(queries, ranges, null);
     421                                Set<ReplayDescriptor> searchResults = ReplayParserGUI.this.presenter.search(queries, ranges, null);
    396422                                replayTableFilter.setObjects(searchResults);
    397423                                replayTableSorter.allRowsChanged();
     
    490516                                                // FIXME: Renderer should be retrieved by a factory
    491517                                                ReplayDescriptor replayDescriptor = (ReplayDescriptor) replayTable.getValueAt(selectedIndex, 0);
    492                                                 Replay replay = ReplayParserGUI.this.warp.getReplay(replayDescriptor);
     518                                                Replay replay = ReplayParserGUI.this.presenter.getReplay(replayDescriptor);
    493519                                                setSelectedReplay(replay);
    494520                                                // FIXME: Find better solution
     
    502528
    503529                // Table popup menu
    504                 final JPopupMenu replayTablePopup = new JPopupMenu();
     530                replayTablePopup = new JPopupMenu();
     531                replayTablePopup.add(new JMenuItem(openReplay));
    505532                replayTablePopup.add(new JMenuItem(deleteReplay));
    506533                replayTable.addMouseListener(new MouseAdapter() {
     
    609636                        DefaultComboBoxModel indices = ((DefaultComboBoxModel) filterMode.getModel());
    610637                        indices.removeAllElements();
    611                         for (String indexName : warp.getIndexNames()) {
     638                        for (String indexName : presenter.getIndexNames()) {
    612639                                indices.addElement(indexName);
    613640                        }
     
    647674                if (userChoice == JOptionPane.YES_OPTION) {
    648675                        setState(State.PARSING);
    649                         warp.parseDir(parsedDir, this);
     676                        presenter.parseDir(parsedDir, this);
    650677                }
    651678        }
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/WARP.java

    r88ead20 rb1df941  
    2626import javax.swing.UIManager.LookAndFeelInfo;
    2727
     28import de.erichseifert.warp.core.DataPresenter;
     29import de.erichseifert.warp.core.io.BufferedStorage;
     30import de.erichseifert.warp.core.io.ReplayStorage;
     31import de.erichseifert.warp.core.io.SerializingStorage;
     32import de.erichseifert.warp.core.io.Settings;
    2833import de.erichseifert.warp.core.ui.WARPUI;
    2934
    30 public class WARP extends de.erichseifert.warp.core.WARP {
     35public class WARP extends DataPresenter {
    3136
    3237        public WARP() {
    33                 WARPUI ui = new ReplayParserGUI(this);
    34                 setUi(ui);
    35         }
     38                ReplayStorage storage = new SerializingStorage();
     39                ReplayStorage storageBuffer = new BufferedStorage(storage);
     40                setStorage(storageBuffer);
    3641
    37         public static void main(String[] args) {
    3842                LookAndFeelInfo[] lafs = UIManager.getInstalledLookAndFeels();
    3943                try {
     
    5761                        e.printStackTrace();
    5862                }
     63                WARPUI ui = new ReplayParserGUI(this);
     64                setUi(ui);
    5965
     66                ui.setReplays(storage.getDescriptors());
     67                boolean parsingComplete = Settings.getInstance().isParsingComplete();
     68                if (!parsingComplete) {
     69                        ui.resumeParsing();
     70                }
     71        }
     72
     73        public static void main(String[] args) {
    6074                new WARP();
    6175        }
Note: See TracChangeset for help on using the changeset viewer.