Changeset 09cc884


Ignore:
Timestamp:
Aug 17, 2010, 10:54:12 AM (8 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
df50e1c
Parents:
f429dec
Message:

Added javadoc comments;
core:
Improve DataPresenter? API;
gui.swing:
After parsing a folder, the user is notified about which files could not have been parsed

Files:
2 edited

Legend:

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

    rf429dec r09cc884  
    2525import java.io.IOException;
    2626import java.util.Collection;
     27import java.util.Collections;
    2728import java.util.HashMap;
     29import java.util.LinkedHashSet;
    2830import java.util.Map;
    2931import java.util.Set;
     
    4345import de.erichseifert.warp.core.util.FileUtil;
    4446
     47/**
     48 * Class that connects the data model with the user interface.
     49 * It provides data to the user interface and initiates administrative
     50 * tasks.
     51 */
    4552public abstract class DataPresenter {
     53        private final Set<File> invalidFiles;
    4654
    4755        /**
    4856         * Class that parses all files in a directory and subdirectories.
    4957         */
    50         private class ParserThread extends Thread {
     58        private static class ParserThread extends Thread {
     59                private static final int walkDepth = 4;
    5160                private final File dir;
     61                private final ReplayStorage storage;
    5262                private final ProgressListener[] listeners;
    5363                private final Map<String, Set<ReplayParser<?>>> replayParserCache;
     64                private final Set<File> invalidFiles;
    5465
    5566                /**
    5667                 * Creates a <code>ParserThread</code> object parsing the
    57                  * specified directory and notfying the specified listeners.
     68                 * specified directory, saving the parsed objects into the
     69                 * specified storage, while files which could not have been parsed
     70                 * are stored in the specified set and the specified listeners
     71                 * are notified upon progress updates.
    5872                 * This thread also descends into subfolders.
    5973                 * @param dir Directory to be searched for parsable files.
     74                 * @param storage Replay storage.
     75                 * @param invalidFiles Set to stored unparsable file in.
    6076                 * @param listeners Listeners to be notified.
    6177                 */
    62                 public ParserThread(File dir, ProgressListener... listeners) {
     78                public ParserThread(File dir, ReplayStorage storage, Set<File> invalidFiles, ProgressListener... listeners) {
    6379                        this.dir = dir;
     80                        this.storage = storage;
    6481                        this.listeners = listeners;
    6582                        replayParserCache = new HashMap<String, Set<ReplayParser<?>>>();
     83                        this.invalidFiles = invalidFiles;
    6684                }
    6785
     
    90108
    91109                                Replay replay = null;
    92                 if(parsers == null) {
    93                     System.err.println(String.format("Could not find parser for file '%s'", replayFile.getAbsolutePath()));
    94                 }
    95                 else {
    96                                         // Parse replay
     110                                // Parse replay
     111                if(parsers != null) {
    97112                                        for (ReplayParser<?> parser : parsers) {
    98113                                                        try {
     
    110125                                if (replay == null) {
    111126                                        System.err.printf("No suitable parser for file %s"+System.getProperty("line.separator"), replayFile.getAbsolutePath());
    112                                         elementsTotal--;
     127                                        invalidFiles.add(replayFile);
    113128                                }
    114129                                else {
    115130                                        storage.save(replay);
    116                                         elementsProcessed++;
    117                                 }
     131                                }
     132                                elementsProcessed++;
    118133
    119134                                // Notify listeners
     
    131146        }
    132147
    133         private static final int walkDepth = 3;
    134 
    135         protected ReplayStorage storage;
    136         protected WARPUI ui;
     148        private ReplayStorage storage;
     149        private WARPUI ui;
    137150
    138151        /**
    139152         * Creates a <code>DataPresenter</code> object.
     153         * This constructor uses a <code>MemoryStorage</code> as storage
     154         * and a <code>CLI</code> as user interface by default.
    140155         */
    141156        protected DataPresenter() {
     
    143158        }
    144159
     160        /**
     161         * Creates a <code>DataPresenter</code> object with the specified
     162         * storage and user interface.
     163         * @param storage Replay storage.
     164         * @param ui User interface.
     165         */
    145166        protected DataPresenter(ReplayStorage storage, WARPUI ui) {
    146167                this.storage = storage;
    147168                this.ui = ui;
     169                invalidFiles = new LinkedHashSet<File>();
    148170        }
    149171
     
    185207                Settings.getInstance().setParsingComplete(false);
    186208
    187                 ParserThread parserThread = new ParserThread(dir, listener);
     209                ParserThread parserThread = new ParserThread(dir, storage, invalidFiles, listener);
    188210                parserThread.start();
    189211        }
     
    226248        }
    227249
    228         public void setUi(WARPUI ui) {
     250        /**
     251         * Sets the user interface to the specified object.
     252         * @param ui User interface.
     253         */
     254        protected void setUi(WARPUI ui) {
    229255                // TODO Dispose old UI
    230256                this.ui = ui;
    231257        }
    232258
    233         public void setStorage(ReplayStorage storage) {
     259        /**
     260         * Sets the used replay storage to the specified object.
     261         * @param storage Replay storage.
     262         */
     263        protected void setStorage(ReplayStorage storage) {
    234264                if (storage != null) {
    235265                        storage.clear();
     
    237267                this.storage = storage;
    238268        }
     269
     270        /**
     271         * Returns a set of files that could not have been parsed.
     272         * @return Unparsable files.
     273         */
     274        public Set<File> getInvalidFiles() {
     275                return Collections.unmodifiableSet(invalidFiles);
     276        }
     277
     278        protected ReplayStorage getStorage() {
     279                return storage;
     280        }
     281
     282        protected WARPUI getUi() {
     283                return ui;
     284        }
    239285}
  • gui.swing/src/main/java/de/erichseifert/warp/gui/swing/ReplayParserGUI.java

    rf429dec r09cc884  
    105105 */
    106106public class ReplayParserGUI extends JFrame implements ReplayDataChangeListener, ProgressListener, WARPUI {
     107        /**
     108         * Enum that represents the state of a GUI.
     109         */
    107110        private static enum State {
     111                /**
     112                 * Indicates that replays are currently parsed.
     113                 */
    108114                PARSING(true, false, "Parsing replays..."),
     115                /**
     116                 * Indicates that already parsed replays are currently loaded.
     117                 */
    109118                BUILDING_DB(true, true, "Building up database..."),
     119                /**
     120                 * Indicates that nothing is happening.
     121                 */
    110122                READY(false, false, "Ready");
    111123
     
    114126                private final String statusMessage;
    115127
     128                /**
     129                 * Creates a <code>State</code> object which specifies whether the
     130                 * progress bar is enabled and whether the progress can be measured,
     131                 * displaying the specified status message.
     132                 * @param progressBarNeeded <code>true</code>, if the progress bar should be enabled, <code>false</code> otherwise.
     133                 * @param indeterminate <code>true</code>, if the progress cannot be measured, <code>false</code> otherwise.
     134                 * @param statusMessage Message to be displayed in the status bar.
     135                 */
    116136                private State(boolean progressBarNeeded, boolean indeterminate, String statusMessage) {
    117137                        this.progressBarNeeded = progressBarNeeded;
     
    120140                }
    121141
     142                /**
     143                 * Returns, whether the progress bar should be enabled.
     144                 * @return <code>true</code>, if the progress bar should be enabled, <code>false</code> otherwise.
     145                 */
    122146                public boolean isProgressBarNeeded() {
    123147                        return progressBarNeeded;
    124148                }
    125149
     150                /**
     151                 * Returns, whether the progress can be measured.
     152                 * @return <code>true</code>, if the progress cannot be measured, <code>false</code> otherwise.
     153                 */
    126154                public boolean isIndeterminate() {
    127155                        return indeterminate;
    128156                }
    129157
     158                /**
     159                 * Returns the status message.
     160                 * @return Status message.
     161                 */
    130162                public String getStatusMessage() {
    131163                        return statusMessage;
     
    186218
    187219        /**
    188          * Creates a new <code>ReplayParserGUI</code> object with the default options.
     220         * Creates a new <code>ReplayParserGUI</code> object using the
     221         * specified data presenter.
    189222         */
    190223        public ReplayParserGUI(DataPresenter presenter) {
     
    223256                        @Override
    224257                        public void actionPerformed(ActionEvent e) {
     258                                // Opens a file chooser dialog where the user can select a single folder
    225259                                JFileChooser fileChooser = new JFileChooser();
    226260                                fileChooser.setMultiSelectionEnabled(false);
     
    228262                                int option = fileChooser.showOpenDialog(ReplayParserGUI.this);
    229263                                if (option == JFileChooser.APPROVE_OPTION) {
     264                                        // Parses the selected folder
    230265                                        setState(State.PARSING);
    231266                                        File dir = fileChooser.getSelectedFile();
     
    241276                        @Override
    242277                        public void actionPerformed(ActionEvent e) {
     278                                // Disposes the GUI
    243279                                dispose();
    244280                        }
     
    249285                        @Override
    250286                        public void actionPerformed(ActionEvent e) {
     287                                // Tries to open the project page
     288                                String projectPageURI = "http://trac.erichseifert.de/warp";
    251289                                try {
    252                                         URI warpProjectPage = new URI("http://trac.erichseifert.de/warp");
     290                                        URI warpProjectPage = new URI(projectPageURI);
    253291                                        Desktop.getDesktop().browse(warpProjectPage);
    254292                                } catch (URISyntaxException e1) {
    255                                         // TODO Auto-generated catch block
    256293                                        e1.printStackTrace();
     294                                        JOptionPane.showMessageDialog(ReplayParserGUI.this, "The URI "+projectPageURI+" is invalid.", "Error while creating URI", JOptionPane.ERROR_MESSAGE);
    257295                                } catch (IOException e2) {
    258                                         // TODO Auto-generated catch block
    259296                                        e2.printStackTrace();
     297                                        JOptionPane.showMessageDialog(ReplayParserGUI.this, "Your default browser could not be opened.", "Error while opening Browser", JOptionPane.ERROR_MESSAGE);
    260298                                }
    261299                        }
    262300                };
    263301                submitBugAction.putValue(Action.NAME, "Submit a bug...");
     302                if (!Desktop.isDesktopSupported() || !Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
     303                        submitBugAction.setEnabled(false);
     304                }
    264305
    265306                Action aboutAction = new AbstractAction() {
    266307                        @Override
    267308                        public void actionPerformed(ActionEvent e) {
     309                                // Opens the about window
    268310                                AboutWindow aboutWindow = new AboutWindow(ReplayParserGUI.this);
    269311                                aboutWindow.setVisible(true);
     
    343385                helpMenu.addSeparator();
    344386                helpMenu.add(aboutAction);
    345                 if (!Desktop.isDesktopSupported() || !Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
    346                         submitBugAction.setEnabled(false);
    347                 }
    348387
    349388                // Tool bar
     
    581620                                setSearchEnabled(true);
    582621                        }
    583                         JOptionPane.showMessageDialog(this, elementsTotal+" replays have been parsed.", "Parsing complete", JOptionPane.INFORMATION_MESSAGE);
     622
     623                        Set<File> unparsedFiles = presenter.getInvalidFiles();
     624                        int parsedFileCount = elementsTotal - unparsedFiles.size();
     625                        Object[] message = new Object[unparsedFiles.size()+2];
     626                        message[0] = parsedFileCount+" replays have been parsed.";
     627                        int optionType = JOptionPane.INFORMATION_MESSAGE;
     628
     629                        if (!unparsedFiles.isEmpty()) {
     630                                optionType = JOptionPane.WARNING_MESSAGE;
     631                                message[1] = "The following files could not have been parsed:";
     632
     633                                int i = 2;
     634                                for (File unparsedFile: unparsedFiles) {
     635                                        message[i] = unparsedFile.getAbsolutePath();
     636                                        i++;
     637                                }
     638                        }
     639
     640                        JOptionPane.showMessageDialog(this, message, "Parsing complete", optionType);
    584641                }
    585642        }
Note: See TracChangeset for help on using the changeset viewer.