Changeset 25127 in osm for applications/editors/josm


Ignore:
Timestamp:
2011-01-24T09:07:41+01:00 (14 years ago)
Author:
beata.jancso
Message:

bug fixes and new features

Location:
applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust
Files:
1 deleted
28 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/MapdustLayer.java

    r24514 r25127  
    6060/**
    6161 * Defines the MapDust JOSM layer main functionality.
    62  *
     62 * 
    6363 * @author Bea
    6464 */
    6565public class MapdustLayer extends Layer {
    66 
     66   
    6767    /** The <code>MapdustGUI</code> object */
    6868    private MapdustGUI mapdustGUI;
    69 
     69   
    7070    /** The list of <code>MapdustBugList</code> objects */
    7171    private List<MapdustBug> mapdustBugList;
    72 
     72   
    7373    /** The selected <code>MapdustBug</code> object */
    7474    private MapdustBug bugSelected;
    75 
     75   
    7676    /**
    7777     * Builds a <code>MapdustLayer</code> object based on the given parameters.
    78      *
     78     * 
    7979     * @param name The name of the layer
    8080     * @param mapdustGUI The <code>MapdustGUI</code> object
    … …  
    8888        this.bugSelected = null;
    8989    }
    90 
     90   
    9191    /**
    9292     * Returns the icon of the MapDust layer.
    93      *
     93     * 
    9494     * @return icon
    9595     */
    … …  
    9999        return layerIcon;
    100100    }
    101 
     101   
    102102    /**
    103103     * Returns the info components of the MapDust layer.
    104      *
     104     * 
    105105     * @return object
    106106     */
    … …  
    110110        return tr(infoComponent);
    111111    }
    112 
     112   
    113113    /**
    114114     * Returns the menu entries of the MapDust layer.
    115      *
     115     * 
    116116     * @return an array of <code>Action</code> objects.
    117117     */
    … …  
    129129        return menuEntries;
    130130    }
    131 
     131   
    132132    /**
    133133     * Returns the text of the tool tip of the MapDust layer.
    134      *
     134     * 
    135135     * @return the tooltip text
    136136     */
    … …  
    140140        return tr(toolTipText);
    141141    }
    142 
     142   
    143143    /**
    144144     * Returns the image icon based on the given status and type.
    145      *
     145     * 
    146146     * @param iconType The type of the bug
    147147     * @param status The status of the bug
    … …  
    158158        return icon;
    159159    }
    160 
     160   
    161161    /**
    162162     * Draw the objects to the given map view. Also draws the MapDust bugs to
    163163     * the map, and the tooltip for the selected MapDust bug.
    164      *
     164     * 
    165165     * @param g The <code>Graphics2D</code> object
    166166     * @param mv The <code>MapView</code> object
    … …  
    181181                int width = icon.getIconWidth();
    182182                int height = icon.getIconHeight();
    183                 /* draw the bug icon */
    184                 /*
    185                  * need to do 2 times, because in some areas the bug image is
    186                  * invisible
    187                  */
     183                /* need to do drawing 2 times, because in some areas the bug
     184                 * image is invisible */
    188185                for (int i = 0; i < 2; i++) {
    189186                    g.drawImage(icon.getImage(), p.x - (width / 2), p.y
    190187                            - (height / 2), new ImageObserver() {
    191 
    192188                        @Override
    193189                        public boolean imageUpdate(Image img, int infoflags,
    … …  
    198194                }
    199195            }
     196           
    200197            /* draw the selected bug description */
    201198            /* selected by clicking */
    … …  
    220217                g.drawImage(icon.getImage(), p.x - (width / 2), p.y
    221218                        - (height / 2), new ImageObserver() {
    222 
    223219                    @Override
    224220                    public boolean imageUpdate(Image img, int infoflags, int x,
    … …  
    246242        }
    247243    }
    248 
     244   
     245    /**
     246     * No need to implement this.
     247     */
    249248    @Override
    250249    public boolean isMergable(Layer layer) {
    251250        return false;
    252251    }
    253 
     252   
     253    /**
     254     * No need to implement this.
     255     */
    254256    @Override
    255257    public void mergeFrom(Layer layer) {}
    256 
     258   
    257259    /**
    258260     * Builds the text of the tooltip containing a short description of the
    259261     * given <code>MapdustBug</code> object.
    260      *
     262     * 
    261263     * @param bug The <code>MapdustBug</code> object
    262264     * @return A string containing the description text
    … …  
    277279        return text;
    278280    }
    279 
     281   
     282    /**
     283     * No need to implement this.
     284     */
    280285    @Override
    281286    public void visitBoundingBox(BoundingXYVisitor arg0) {}
    282 
     287   
    283288    /**
    284289     * Returns the <code>MapdustGUI</code> object
    285      *
     290     * 
    286291     * @return the mapdustGUI
    287292     */
    … …  
    289294        return mapdustGUI;
    290295    }
    291 
     296   
    292297    /**
    293298     * Sets the <code>MapdustGUI</code> object
    294      *
     299     * 
    295300     * @param mapdustGUI the mapdustGUI to set
    296301     */
    … …  
    298303        this.mapdustGUI = mapdustGUI;
    299304    }
    300 
     305   
    301306    /**
    302307     * Returns the list of <code>MapdustBug</code> objects
    303      *
     308     * 
    304309     * @return the mapdustBugList
    305310     */
    … …  
    307312        return mapdustBugList;
    308313    }
    309 
     314   
    310315    /**
    311316     * Returns the selected bug
    312      *
     317     * 
    313318     * @return the bugSelected
    314319     */
    … …  
    316321        return bugSelected;
    317322    }
    318 
     323   
    319324    /**
    320325     * Sets the selected bug
    321      *
     326     * 
    322327     * @param bugSelected the bugSelected to set
    323328     */
    … …  
    325330        this.bugSelected = bugSelected;
    326331    }
    327 
     332   
    328333    /**
    329334     * Sets the list of <code>MapdustBug</code> objects
     335     *
    330336     * @param mapdustBugList the mapdustBugList to set
    331337     */

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/MapdustPlugin.java

    r24821 r25127  
    4242import org.openstreetmap.josm.gui.MapView;
    4343import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
     44import org.openstreetmap.josm.gui.NavigatableComponent;
    4445import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
    4546import org.openstreetmap.josm.gui.layer.Layer;
    … …  
    6061
    6162/**
    62  * This is the main class of the MapDust plugin. Defines the MapDust plugin main
    63  * functionality.
     63 * This is the main class of the MapDust plug-in. Defines the MapDust plug-in
     64 * main functionality.
    6465 *
    6566 * @author Bea
    … …  
    6970        ZoomChangeListener, MouseListener, MapdustRefreshObserver,
    7071        MapdustBugObserver, MapdustInitialUpdateObserver {
    71    
    72     /** The graphical user interface of the plugin */
     72
     73    /** The graphical user interface of the plug-in */
    7374    private MapdustGUI mapdustGUI;
    74    
    75     /** The layer of the MapDust plugin */
     75
     76    /** The layer of the MapDust plug-in */
    7677    private MapdustLayer mapdustLayer;
    77    
     78
    7879    /** The list of <code>MapdustBug</code> objects */
    7980    private List<MapdustBug> mapdustBugList;
    80    
    81     /** Flag indicating if the list of bugs was empty or not */
    82     private boolean wasEmpty;
    83    
     81
     82    /** The <code>CreateIssueDialog</code> object */
     83    private CreateIssueDialog dialog;
     84
     85    /** Specifies if there was or not an error downloading the data */
     86    private boolean wasError = false;
     87
    8488    /**
    8589     * Builds a new <code>MapDustPlugin</code> object based on the given
    8690     * arguments.
    87      * 
     91     *
    8892     * @param info The <code>MapDustPlugin</code> object
    8993     */
    9094    public MapdustPlugin(PluginInformation info) {
    9195        super(info);
    92         Main.pref.put("mapdust.pluginState",
    93                 MapdustPluginState.ONLINE.getValue());
     96        initializePlugin();
     97    }
     98
     99    /**
     100     * Initialize the <code>MapdustPlugin</code> object. Creates the
     101     * <code>MapdustGUI</code> and initializes the following variables with
     102     * default values: 'mapdust.pluginState', 'mapdust.nickname',
     103     * 'mapdust.showError'.
     104     */
     105    private void initializePlugin() {
     106        /* create MapDust GUI */
     107        Shortcut shortcut = Shortcut.registerShortcut("mapdust",
     108                tr("Toggle: {0}", tr("Open MapDust")), KeyEvent.VK_0,
     109                Shortcut.GROUP_MENU, Shortcut.SHIFT_DEFAULT);
     110        String name = "MapDust bug reports";
     111        String tooltip = "Activates the MapDust bug reporter plugin";
     112        mapdustGUI = new MapdustGUI(tr(name), "mapdust_icon.png", tr(tooltip),
     113                shortcut, 150, this);
     114        /* add default values for static variables */
     115        Main.pref.put("mapdust.pluginState", MapdustPluginState.ONLINE.getValue());
    94116        Main.pref.put("mapdust.nickname", null);
    95         Main.pref.put("mapdust.modify", false);
    96     }
    97    
    98     /**
    99      * Initializes the new view with the MapDust Bugs from that area.
    100      *
     117        Main.pref.put("mapdust.showError", true);
     118    }
     119
     120    /**
     121     * Initializes the new <code>MapFrame</code>. Adds the
     122     * <code>MapdustGUI</code> to the new <code>MapFrame</code> and sets the
     123     * observers/listeners.
     124     *
    101125     * @param oldMapFrame The old <code>MapFrame</code> object
    102126     * @param newMapFrame The new <code>MapFrame</code> object
    … …  
    107131            /* if new MapFrame is null, remove listener */
    108132            MapView.removeLayerChangeListener(this);
     133            NavigatableComponent.removeZoomChangeListener(this);
    109134        } else {
    110135            /* add MapDust dialog window */
    111             Shortcut shortcut = Shortcut.registerShortcut("mapdust",
    112                     tr("Toggle: {0}", tr("Open MapDust")), KeyEvent.VK_0,
    113                     Shortcut.GROUP_MENU, Shortcut.SHIFT_DEFAULT);
    114             String name = "MapDust bug reports";
    115             String tooltip = "Activates the MapDust bug reporter plugin";
    116             mapdustGUI = new MapdustGUI(tr(name), "mapdust_icon.png", tr(tooltip),
    117                     shortcut, 150, this);
    118             mapdustGUI.setBounds(newMapFrame.getBounds());
    119             mapdustGUI.addObserver(this);
    120             newMapFrame.addToggleDialog(mapdustGUI);
    121             MapView.addZoomChangeListener(this);
    122             MapView.addLayerChangeListener(this);
    123             Main.map.mapView.addMouseListener(this);
    124         }
    125     }
    126    
    127     /**
    128      * Updates the MapDust plugin data. Downloads the list of
    129      * <code>MapdustBug</code> objects for the given area, and updates the map
    130      * and the Mapdust layer with the new data.
    131      */
    132     @Override
    133     public synchronized void updateData() {
    134         if (Main.map != null && Main.map.mapView != null) {
    135             try {
    136                 /* downloads the MapDust bugs */
    137                 this.mapdustBugList = getMapdustBugs();
    138                 if (getMapdustGUI().isDialogShowing()) {
    139                     /* updates the views */
    140                     if ((this.mapdustBugList == null || this.mapdustBugList
    141                             .size() == 0) && !wasEmpty) {
    142                         updateView();
    143                         String waringMessage = "There is no MapDust bug in ";
    144                         waringMessage += "your visible area.";
    145                         JOptionPane.showMessageDialog(Main.parent,
    146                                 tr(waringMessage), tr("Warning"),
    147                                 JOptionPane.WARNING_MESSAGE);
    148                         wasEmpty = true;
    149                     } else {
    150                         updateView();
    151                         wasEmpty = false;
    152                     }
    153                 }
    154             } catch (MapdustServiceHandlerException e) {
    155                 /* show errprMessage, and remove the layer */
    156                 String errorMessage = "There was a Mapdust service error.";
    157                 errorMessage += " Please try later.";
    158                 JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
    159                         tr("Error"), JOptionPane.ERROR_MESSAGE);
    160                 MapView.removeLayerChangeListener(this);
    161                 Main.map.mapView.removeLayer(mapdustLayer);
    162                 Main.map.remove(mapdustGUI);
    163             }
    164         }
    165     }
    166    
     136            if (Main.map != null && Main.map.mapView != null) {
     137                /* set bounds for MapdustGUI */
     138                mapdustGUI.setBounds(newMapFrame.getBounds());
     139                /* add observer */
     140                mapdustGUI.addObserver(this);
     141                /* add dialog to new MapFrame */
     142                newMapFrame.addToggleDialog(mapdustGUI);
     143                /* add ZoomChangeListener */
     144                NavigatableComponent.addZoomChangeListener(this);
     145                /* add LayerChangeListener */
     146                MapView.addLayerChangeListener(this);
     147                /* add MouseListener */
     148                Main.map.mapView.addMouseListener(this);
     149            }
     150        }
     151    }
     152
     153    /**
     154     * Refreshes the MapDust data. Downloads the data from the given area and
     155     * updates the map and the MapDust list with this new data. This method is
     156     * called whenever the 'Refresh' button is pressed by the user.
     157     */
     158    @Override
     159    public void refreshData() {
     160        if (containsOsmDataLayer() && mapdustGUI.isShowing()) {
     161            updatePluginData();
     162        }
     163    }
     164
     165    /**
     166     * Downloads the MapDust bugs from the current map view, and updates the
     167     * plugin data with the new downloaded data. This method is called only
     168     * once, before first showing the MapDust bugs.
     169     */
     170    @Override
     171    public void initialUpdate() {
     172        if (containsOsmDataLayer()) {
     173            updatePluginData();
     174        }
     175    }
     176
    167177    /**
    168178     * Updates the given <code>MapdustBug</code> object from the map and from
    169179     * the MapDust bugs list.
    170      * 
     180     *
    171181     * @param mapdustBug The <code>MapdustBug</code> object
    172182     */
    173183    @Override
    174184    public synchronized void changedData(MapdustBug mapdustBug) {
    175         if (this.mapdustBugList == null) {
    176             this.mapdustBugList = new ArrayList<MapdustBug>();
     185        if (mapdustBugList == null) {
     186            mapdustBugList = new ArrayList<MapdustBug>();
    177187        }
    178188        if (getMapdustGUI().isDialogShowing()) {
    … …  
    197207        }
    198208    }
    199    
     209
     210    /**
     211     * If the zoom was changed, download the bugs from the current map view.
     212     * This method is called whenever the zoom was changed.
     213     */
     214    @Override
     215    public void zoomChanged() {
     216        if (containsOsmDataLayer() && this.mapdustGUI.isShowing() && !wasError) {
     217            updatePluginData();
     218        }
     219    }
     220
     221    /**
     222     * No need to implement this.
     223     */
    200224    @Override
    201225    public void activeLayerChange(Layer arg0, Layer arg1) {}
    202    
     226
     227    /**
     228     * Adds the <code>MapdustLayer</code> to the JOSM editor. If the list of
     229     * <code>MapdustBug</code>s is null then downloads the data from the MapDust
     230     * Service and updates the editor with this new data.
     231     *
     232     * @param layer The <code>Layer</code> which will be added to the JOSM
     233     * editor
     234     */
    203235    @Override
    204236    public void layerAdded(Layer layer) {
    205237        if (layer instanceof MapdustLayer) {
    206238            /* download the MapDust bugs and update the plugin */
    207             updateData();
    208         }
    209     }
    210    
     239            if (mapdustBugList == null) {
     240                updateMapdustData();
     241            }
     242        }
     243    }
     244
     245    /**
     246     * Removes the <code>MapdustLayer</code> from the JOSM editor. Also closes
     247     * the MapDust plugin window.
     248     *
     249     * @param layer The <code>Layer</code> which will be removed from the JOSM
     250     * editor
     251     */
    211252    @Override
    212253    public void layerRemoved(Layer layer) {
    … …  
    214255            /* remove the layer */
    215256            MapView.removeLayerChangeListener(this);
    216             MapView.removeZoomChangeListener(this);
     257            NavigatableComponent.removeZoomChangeListener(this);
    217258            Main.map.mapView.removeLayer(layer);
    218259            Main.map.remove(mapdustGUI);
    219260            if (mapdustGUI != null) {
    220                 mapdustGUI.update(null, this);
     261                mapdustGUI.update(new ArrayList<MapdustBug>(), this);
     262                mapdustGUI.setVisible(false);
    221263            }
    222264            mapdustLayer = null;
    223             wasEmpty = false;
    224         }
    225     }
    226    
     265        }
     266    }
     267
     268    /**
     269     * No need to implement this.
     270     */
     271    @Override
     272    public void mouseEntered(MouseEvent event) {}
     273
     274    /**
     275     * No need to implement this.
     276     */
     277    @Override
     278    public void mouseExited(MouseEvent arg0) {}
     279
     280    /**
     281     * No need to implement this.
     282     */
     283    @Override
     284    public void mousePressed(MouseEvent event) {}
     285
     286    /**
     287     * No need to implement this.
     288     */
     289    @Override
     290    public void mouseReleased(MouseEvent arg0) {}
     291
     292    /**
     293     * At mouse click the following two actions can be done: adding a new bug,
     294     * and selecting a bug from the map. A bug can be added if the plugin is the
     295     * only active plugin and you double click on the map. You can select a bug
     296     * from the map by clicking on it.
     297     *
     298     * @event The <code>MouseEvent</code> object
     299     */
    227300    @Override
    228301    public void mouseClicked(MouseEvent event) {
    229         if (mapdustLayer != null && mapdustLayer.isVisible()
    230                 && Main.map.mapView.getActiveLayer() == getMapdustLayer()) {
    231             /* show add bug dialog */
    232             if (event.getButton() == MouseEvent.BUTTON3
    233                     && event.getClickCount() == 2) {
    234                 String mapdustAddBug = Main.pref.get("mapdust.addBug");
    235                 boolean addBug = Boolean.parseBoolean(mapdustAddBug);
    236                 if (!addBug) {
    237                     mapdustGUI.getPanel().getBtnPanel().getBtnWorkOffline()
    238                             .setEnabled(false);
    239                     mapdustGUI.getPanel().getBtnPanel().getBtnRefresh()
    240                             .setEnabled(false);
    241                     mapdustGUI.getPanel().getBtnPanel().getBtnAddComment()
    242                             .setEnabled(false);
    243                     mapdustGUI.getPanel().getBtnPanel().getBtnFixBugReport()
    244                             .setEnabled(false);
    245                     mapdustGUI.getPanel().getBtnPanel()
    246                             .getBtnInvalidateBugReport().setEnabled(false);
    247                     mapdustGUI.getPanel().getBtnPanel().getBtnReOpenBugReport()
    248                             .setEnabled(false);
    249                     Main.pref.put("mapdust.modify", true);
    250                     MapdustBug selectedBug =
    251                             mapdustGUI.getPanel().getSelectedBug();
    252                     if (selectedBug != null) {
    253                         Main.pref.put("selectedBug.status", selectedBug
    254                                 .getStatus().getValue());
    255                     } else {
    256                         Main.pref.put("selectedBug.status", "create");
     302        if (mapdustLayer != null && mapdustLayer.isVisible()) {
     303            if (event.getButton() == MouseEvent.BUTTON1) {
     304                if (event.getClickCount() == 2 && !event.isConsumed()) {
     305                    if (Main.map.mapView.getActiveLayer() == getMapdustLayer()) {
     306                        /* show add bug dialog */
     307                        MapdustBug bug = mapdustGUI.getPanel().getSelectedBug();
     308                        if (bug != null) {
     309                            Main.pref.put("selectedBug.status", bug.getStatus()
     310                                    .getValue());
     311                        } else {
     312                            Main.pref.put("selectedBug.status", "create");
     313                        }
     314                        /* disable MapdustButtonPanel */
     315                        mapdustGUI.disableBtnPanel();
     316                        /* create and show dialog */
     317                        dialog = new CreateIssueDialog(event.getPoint(), this);
     318                        dialog.showDialog();
     319                        event.consume();
     320                        return;
    257321                    }
    258                     String title = "Create bug report";
    259                     String iconName = "dialogs/open.png";
    260                     String messageText =
    261                             "In order to create a new bug report you";
    262                     messageText += " need to provide your nickname and a brief";
    263                     messageText += " description for the bug.";
    264                     Point point = event.getPoint();
    265                     CreateIssueDialog dialog =
    266                             new CreateIssueDialog(tr(title), iconName,
    267                                     tr(messageText), point, this);
    268                     dialog.setLocationRelativeTo(null);
    269                     dialog.getContentPane().setPreferredSize(dialog.getSize());
    270                     dialog.pack();
    271                     dialog.setVisible(true);
    272                 } else {
    273                     Main.pref.put("mapdust.addBug", false);
    274322                }
    275             }
    276             if (event.getButton() == MouseEvent.BUTTON1) {
    277                 /* allow click on the bug icon on the map */
    278                 Point p = event.getPoint();
    279                 MapdustBug nearestBug = getNearestBug(p);
    280                 if (nearestBug != null) {
    281                     mapdustLayer.setBugSelected(nearestBug);
    282                     /* set also in the list of bugs the element */
    283                     mapdustGUI.getPanel().setSelectedBug(nearestBug);
    284                     Main.map.mapView.repaint();
     323                if (event.getClickCount() == 1 && !event.isConsumed()) {
     324                    /* allow click on the bug icon on the map */
     325                    Point p = event.getPoint();
     326                    MapdustBug nearestBug = getNearestBug(p);
     327                    if (nearestBug != null) {
     328                        mapdustLayer.setBugSelected(nearestBug);
     329                        /* set also in the list of bugs the element */
     330                        mapdustGUI.getPanel().setSelectedBug(nearestBug);
     331                        Main.map.mapView.repaint();
     332                    }
     333                    return;
    285334                }
    286335            }
    287336        }
    288337    }
    289    
    290     /**
    291      * Updates the current view, with the given list of <code>MapdustBug</code>
    292      * objects.
     338
     339
     340    /**
     341     * Updates the <code>MapdustPlugin</code> data. Downloads the
     342     * <code>MapdustBug</code> objects from the current view, and updates the
     343     * <code>MapdustGUI</code> and the map with the new data.
     344     */
     345    private void updatePluginData() {
     346        Main.worker.execute(new Runnable() {
     347            @Override
     348            public void run() {
     349                updateMapdustData();
     350            }
     351        });
     352    }
     353
     354    /**
     355     * Returns the bounds of the current <code>MapView</code>.
     356     *
     357     * @return bounds
     358     */
     359    private Bounds getBounds() {
     360        MapView mapView = Main.map.mapView;
     361        Bounds bounds = new Bounds(mapView.getLatLon(0, mapView.getHeight()),
     362                mapView.getLatLon(mapView.getWidth(), 0));
     363        return bounds;
     364    }
     365
     366    /**
     367     * Updates the MapDust plugin data. Downloads the list of
     368     * <code>MapdustBug</code> objects for the given area, and updates the map
     369     * and the MapDust layer with the new data.
     370     */
     371    private synchronized void updateMapdustData() {
     372        if (Main.map != null && Main.map.mapView != null) {
     373            /* download the MapDust data */
     374            try {
     375                Bounds bounds = getBounds();
     376                MapdustServiceHandler handler = new MapdustServiceHandler();
     377                mapdustBugList = handler.getBugs(bounds.getMin().lon(),
     378                        bounds.getMin().lat(), bounds.getMax().lon(),
     379                        bounds.getMax().lat());
     380                wasError = false;
     381            } catch (MapdustServiceHandlerException e) {
     382                wasError = true;
     383                mapdustBugList = new ArrayList<MapdustBug>();
     384                updateView();
     385                handleError();
     386            }
     387            /* update the view */
     388            if (!wasError) {
     389                updateView();
     390            }
     391        }
     392    }
     393
     394    /**
     395     * Updates the current view ( map and MapDust bug list), with the given list
     396     * of <code>MapdustBug</code> objects.
    293397     */
    294398    private void updateView() {
    295399        /* update the dialog with the new data */
    296400        mapdustGUI.update(mapdustBugList, this);
     401        mapdustGUI.setVisible(true);
    297402        mapdustGUI.revalidate();
     403        /* update the MapdustLayer */
    298404        if (mapdustLayer == null) {
    299405            /* create and add the layer */
    300             mapdustLayer =
    301                     new MapdustLayer("MapDust", mapdustGUI, mapdustBugList);
    302             Main.main.addLayer(mapdustLayer);
    303             Main.map.mapView.moveLayer(mapdustLayer, 0);
    304             ;
     406            mapdustLayer = new MapdustLayer("MapDust", mapdustGUI, mapdustBugList);
     407            Main.main.addLayer(this.mapdustLayer);
     408            Main.map.mapView.moveLayer(this.mapdustLayer, 0);
    305409            Main.map.mapView.addMouseListener(this);
    306410            MapView.addLayerChangeListener(this);
    307             MapView.addZoomChangeListener(this);
     411            NavigatableComponent.addZoomChangeListener(this);
    308412        } else {
    309413            /* re-set the properties */
    … …  
    317421        Main.map.repaint();
    318422    }
    319    
    320     /**
    321      * Downloads the MapDust bugs from the current map view, and updates the
    322      * plugin data with the new downloaded data.
    323      */
    324     @Override
    325     public void initialUpdate() {
    326         if (containsOsmDataLayer()) {
    327             updateData();
    328         }
    329     }
    330    
    331     /**
    332      * If the zoom was changed, download the bugs from the current map view.
    333      */
    334     @Override
    335     public void zoomChanged() {
    336         updateData();
    337     }
    338    
    339     /**
    340      * Verifies if the <code>OsmDataLayer</code> layer has been added to the
    341      * list of layers.
    342      *
    343      * @return true if the <code>OsmDataLayer</code> layer has been added false
    344      * otherwise
    345      */
    346     private boolean containsOsmDataLayer() {
    347         boolean contains = false;
    348         List<Layer> l = Main.map.mapView.getAllLayersAsList();
    349         for (Layer ll : l) {
    350             if (ll instanceof OsmDataLayer) {
    351                 contains = true;
    352             }
    353         }
    354         return contains;
    355     }
    356    
     423
    357424    /**
    358425     * Updates the MapDust bugs list with the given <code>MapdustBug</code>
    359426     * object.
    360      * 
     427     *
    361428     * @param mapdustBug The <code>MapdustBug</code> object
    362429     */
    363430    private void updateMapdustBugList(MapdustBug mapdustBug) {
    364431        MapdustBug oldBug = null;
    365         for (MapdustBug bug : mapdustBugList) {
     432        for (MapdustBug bug : this.mapdustBugList) {
    366433            if (bug.getId().equals(mapdustBug.getId())) {
    367434                oldBug = bug;
    … …  
    370437        if (oldBug != null) {
    371438            /* remove, add */
    372             mapdustBugList.remove(oldBug);
    373             mapdustBugList.add(0, mapdustBug);
     439            this.mapdustBugList.remove(oldBug);
     440            this.mapdustBugList.add(0, mapdustBug);
    374441        } else {
    375442            /* new add */
    376             mapdustBugList.add(0, mapdustBug);
    377         }
    378     }
    379    
    380     /**
    381      * Returns the list of <code>MapdustBug</code> objects from the current
    382      * area.
    383      *
    384      * @return A list of <code>MapdustBug</code> objects
    385      * @throws MapdustServiceHandlerException In the case of a MapDust service
    386      * error
    387      */
    388     private List<MapdustBug> getMapdustBugs()
    389             throws MapdustServiceHandlerException {
    390         /* get the bounding box */
    391         MapView mapView = Main.map.mapView;
    392         Bounds bounds =
    393                 new Bounds(mapView.getLatLon(0, mapView.getHeight()),
    394                         mapView.getLatLon(mapView.getWidth(), 0));
    395         Double minLon = bounds.getMin().lon();
    396         Double minLat = bounds.getMin().lat();
    397         Double maxLon = bounds.getMax().lon();
    398         Double maxLat = bounds.getMax().lat();
    399        
    400         /* get the bugs from the bounding box */
    401         MapdustServiceHandler handler = new MapdustServiceHandler();
    402         List<MapdustBug> list = handler.getBugs(minLon, minLat, maxLon, maxLat);
    403         return list;
    404     }
    405    
     443            this.mapdustBugList.add(0, mapdustBug);
     444        }
     445    }
     446
    406447    /**
    407448     * Returns the nearest <code>MapdustBug</code> object to the given point on
    408449     * the map.
    409      * 
     450     *
    410451     * @param p A <code>Point</code> object
    411452     * @return A <code>MapdustBug</code> object
    … …  
    427468        return nearestBug;
    428469    }
    429    
    430     @Override
    431     public void mouseEntered(MouseEvent event) {
    432 
    433     }
    434    
    435     @Override
    436     public void mouseExited(MouseEvent arg0) {}
    437    
    438     @Override
    439     public void mousePressed(MouseEvent event) {
    440 
    441     }
    442    
    443     @Override
    444     public void mouseReleased(MouseEvent arg0) {}
    445    
     470
     471    /**
     472     * Verifies if the <code>OsmDataLayer</code> layer has been added to the
     473     * list of layers.
     474     *
     475     * @return true if the <code>OsmDataLayer</code> layer has been added false
     476     * otherwise
     477     */
     478    private boolean containsOsmDataLayer() {
     479        boolean contains = false;
     480        List<Layer> l = Main.map.mapView.getAllLayersAsList();
     481        for (Layer ll : l) {
     482            if (ll instanceof OsmDataLayer) {
     483                contains = true;
     484            }
     485        }
     486        return contains;
     487    }
     488
     489    /**
     490     * Handles the <code>MapdustServiceHandlerException</code> error.
     491     *
     492     */
     493    private void handleError() {
     494        String showMessage = Main.pref.get("mapdust.showError");
     495        Boolean showErrorMessage = Boolean.parseBoolean(showMessage);
     496        if (showErrorMessage) {
     497            /* show errprMessage, and remove the layer */
     498            Main.pref.put("mapdust.showError", false);
     499            String errorMessage = "There was a Mapdust service error.";
     500            errorMessage += " Please try later.";
     501            JOptionPane.showMessageDialog(Main.parent, tr(errorMessage));
     502        }
     503    }
     504
    446505    /**
    447506     * Returns the <code>MapdustGUI</code> object
    448      * 
     507     *
    449508     * @return the mapdustGUI
    450509     */
    … …  
    452511        return mapdustGUI;
    453512    }
    454    
     513
    455514    /**
    456515     * Sets the <code>MapdustGUI</code> object.
    457      * 
     516     *
    458517     * @param mapdustGUI the mapdustGUI to set
    459518     */
    … …  
    461520        this.mapdustGUI = mapdustGUI;
    462521    }
    463    
     522
    464523    /**
    465524     * Returns the <code>MapdustLayer</code> object.
    466      * 
     525     *
    467526     * @return the mapdustLayer
    468527     */
    … …  
    470529        return mapdustLayer;
    471530    }
    472    
     531
    473532    /**
    474533     * Sets the <code>MapdustLayer</code> object.
    475      * 
     534     *
    476535     * @param mapdustLayer the mapdustLayer to set
    477536     */
    … …  
    479538        this.mapdustLayer = mapdustLayer;
    480539    }
    481    
     540
    482541    /**
    483542     * Returns the list of <code>MapdustBug</code> objects
    484      * 
     543     *
    485544     * @return the mapdustBugList
    486545     */
    … …  
    488547        return mapdustBugList;
    489548    }
    490    
     549
    491550    /**
    492551     * Sets the list of <code>MapdustBug</code> objects
    493      * 
     552     *
    494553     * @param mapdustBugList the mapdustBugList to set
    495554     */
    … …  
    497556        this.mapdustBugList = mapdustBugList;
    498557    }
    499    
     558
    500559}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/MapdustGUI.java

    r24821 r25127  
    3333import java.util.ArrayList;
    3434import java.util.Iterator;
    35 import java.util.LinkedList;
    3635import java.util.List;
    3736import javax.swing.JPanel;
    … …  
    8786   
    8887    /** The <code>MapdustBugPropertiesPanel</code> */
    89     private final MapdustBugPropertiesPanel detailsPanel;
     88    private MapdustBugPropertiesPanel detailsPanel;
    9089   
    9190    /** The <code>JPanel</code> */
    9291    private JPanel mainPanel;
    9392   
    94     /**
    95      * Flag indicating if the MapDust data was downloaded and the view was
    96      * updated
    97      */
    98     private boolean initialUpdate = false;
     93    /** Specifies if the MapDust data was or not downloaded */
     94    private boolean downloaded = false;
    9995   
    10096    /**
    … …  
    112108        super(tr(name), iconName, tr(tooltip), shortcut, preferredHeight);
    113109        this.mapdustPlugin = mapdustPlugin;
    114         panel = new MapdustPanel(mapdustPlugin.getMapdustBugList(),
    115                 "Bug reports", mapdustPlugin);
    116         MapdustBug bug = null;
    117         if (mapdustPlugin.getMapdustBugList() != null
    118                 && mapdustPlugin.getMapdustBugList().size() > 0) {
    119             bug = mapdustPlugin.getMapdustBugList().get(0);
    120         }
    121         detailsPanel = new MapdustBugPropertiesPanel(bug);
    122         panel.addObserver(detailsPanel);
    123         addObserver(detailsPanel);
    124         String pluginState = Main.pref.get("mapdust.pluginState");
    125         if (pluginState.equals(MapdustPluginState.OFFLINE.getValue())) {
    126             /* offline mode, need to add also queue panel */
    127             tabbedPane = new JTabbedPane();
    128             List<MapdustAction> list = new LinkedList<MapdustAction>();
    129             mainPanel = new JPanel();
    130             mainPanel.setAutoscrolls(true);
    131             mainPanel.setLayout(new BorderLayout(5, 10));
    132             mainPanel.add(detailsPanel, BorderLayout.NORTH);
    133             mainPanel.add(panel, BorderLayout.CENTER);
    134             queuePanel = new MapdustActionPanel(list, "Work offline", mapdustPlugin);
    135             tabbedPane.add(mainPanel, 0);
    136             tabbedPane.add(queuePanel);
    137             add(tabbedPane, BorderLayout.CENTER);
    138         } else {
    139             /* online mode */
    140             mainPanel = new JPanel();
    141             mainPanel.setIgnoreRepaint(true);
    142             mainPanel.setAutoscrolls(true);
    143             mainPanel.setLayout(new BorderLayout(5, 10));
    144             mainPanel.add(detailsPanel, BorderLayout.NORTH);
    145             mainPanel.add(panel, BorderLayout.CENTER);
    146             add(mainPanel, BorderLayout.CENTER);
    147             tabbedPane = null;
    148             queuePanel = null;
    149         }
    150110    }
    151111   
    … …  
    165125            if (tabbedPane != null) {
    166126                /* offline to online */
    167                 tabbedPane.remove(panel);
    168                 tabbedPane.remove(queuePanel);
    169                 mainPanel.remove(tabbedPane);
    170127                remove(mainPanel);
    171128                queuePanel = null;
    172129            } else {
    173130                /* online to online */
    174                 mainPanel.remove(detailsPanel);
    175                 mainPanel.remove(panel);
    176                 remove(mainPanel);
     131                if (mainPanel != null) {
     132                    remove(mainPanel);
     133                }
    177134            }
    178135            /* add panels with updated data */
    179136            panel = new MapdustPanel(mapdustBugs, "Bug reports", mapdustPlugin);
    180             MapdustBug selectedBug =
    181                     (mapdustBugs != null && mapdustBugs.size() > 0) ? mapdustBugs
    182                             .get(0) : null;
     137            MapdustBug selectedBug = (mapdustBugs != null && mapdustBugs.size()
     138                    > 0) ? mapdustBugs.get(0) : null;
     139            if (detailsPanel == null) {
     140                detailsPanel = new MapdustBugPropertiesPanel(selectedBug);
     141                panel.addObserver(detailsPanel);
     142                addObserver(detailsPanel);
     143            }
    183144            notifyObservers(selectedBug);
    184145            panel.addObserver(detailsPanel);
    … …  
    196157            if (queuePanel == null) {
    197158                /* from online to offline */
    198                 mainPanel.remove(detailsPanel);
    199                 mainPanel.remove(panel);
    200159                remove(mainPanel);
    201160            } else {
    202161                list = queuePanel.getActionList();
    203                 mainPanel.remove(detailsPanel);
    204                 tabbedPane.remove(panel);
    205                 tabbedPane.remove(queuePanel);
    206                 mainPanel.remove(tabbedPane);
    207162                remove(mainPanel);
    208163            }
    … …  
    213168            panel = new MapdustPanel(mapdustBugs, "Bug reports (offline)",
    214169                    mapdustPlugin);
     170            MapdustBug selectedBug = (mapdustBugs != null && mapdustBugs.size()
     171                    > 0) ? mapdustBugs.get(0) : null;
     172            if (detailsPanel == null) {
     173                detailsPanel = new MapdustBugPropertiesPanel(selectedBug);
     174                panel.addObserver(detailsPanel);
     175                addObserver(detailsPanel);
     176            }
     177            notifyObservers(selectedBug);
     178            panel.addObserver(detailsPanel);
    215179            mainPanel = new JPanel();
    216180            mainPanel.setAutoscrolls(true);
    217181            mainPanel.setLayout(new BorderLayout());
    218             if (mapdustBugs != null && mapdustBugs.size() > 0) {
     182            if (mapdustBugs != null) {
    219183                mainPanel.add(detailsPanel, BorderLayout.NORTH);
    220184            }
    … …  
    239203       
    240204        /* remove panels */
    241         mainPanel.remove(detailsPanel);
    242         tabbedPane.remove(panel);
    243         tabbedPane.remove(queuePanel);
    244         mainPanel.remove(tabbedPane);
    245         remove(mainPanel);
     205        if (mainPanel != null) {
     206            remove(mainPanel);
     207        }
    246208        /* create new tabbed pane */
    247209        tabbedPane = new JTabbedPane();
    … …  
    263225   
    264226    /**
    265      * Shows the MapDust main dialog. In the case if the plugin was not updated
    266      * with the new MapDust data, or the data was not downloaded; it will also
    267      * download the MapDust data from the current view, and update the plugin
    268      * with the new data.
    269      *
    270      */
    271     @Override
    272     public void showDialog() {
    273         super.showDialog();
    274         /* was not updated */
    275         if (!initialUpdate && isShowing) {
    276             notifyObservers();
    277             initialUpdate = true;
    278         }
    279     }
     227     * Disables the buttons from the <code>MapdustButtonPanel</code> buttons.
     228     *
     229     */
     230    public void disableBtnPanel() {
     231        panel.getBtnPanel().getBtnWorkOffline().setEnabled(false);
     232        panel.getBtnPanel().getBtnRefresh().setEnabled(false);
     233        panel.getBtnPanel().getBtnAddComment().setEnabled(false);
     234        panel.getBtnPanel().getBtnFixBugReport().setEnabled(false);
     235        panel.getBtnPanel().getBtnInvalidateBugReport().setEnabled(false);
     236        panel.getBtnPanel().getBtnReOpenBugReport().setEnabled(false);
     237    }
     238   
    280239   
    281240    /**
    … …  
    307266   
    308267    /**
     268     * Displays the <code>MapdustGUI</code> dialog window in the JOSM editor. If
     269     * the MapDust data was not downloaded yet, it will donwload the data and
     270     * also update the MapDust plugin with the data. If the MapDust data was
     271     * already downloaded, then the <code>MapdustGUI</code> will be displayed.
     272     */
     273    @Override
     274    public void showDialog() {
     275        if (!downloaded) {
     276            notifyObservers();
     277            downloaded = true;
     278        }
     279        super.showDialog();
     280    }
     281   
     282    /**
    309283     * Adds a new MapDust bug details observer to the list of observers.
    310284     *

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/adapter/WindowClose.java

    r24821 r25127  
    4141/**
    4242 * Closes the given dialog window.
    43  * 
     43 *
    4444 * @author Bea
    4545 * @version $Revision$
    4646 */
    4747public class WindowClose extends WindowAdapter {
    48    
     48
    4949    /** Serial version UID */
    5050    private static final long serialVersionUID = 1L;
    51    
     51
    5252    /** A <code>AbstractDialog</code> object */
    5353    private AbstractDialog dialog;
    54    
     54
    5555    /** The <code>MapdustButtonPanel</code> object */
    5656    private MapdustButtonPanel btnPanel;
    57    
     57
    5858    /** The <code>JToggleButton</code> which had fired the dialog */
    5959    private JToggleButton btnFired;
    60    
     60
    6161    /**
    6262     * Builds a <code>WindowClose</code> object
    6363     */
    6464    public WindowClose() {}
    65    
     65
    6666    /**
    6767     * Builds a <code>WindowClose</code> object based on the given arguments
    68      * 
     68     *
    6969     * @param dialog The dialog which will be closed
    7070     * @param btnPanel The button panel
    … …  
    7777        this.btnFired = btnFired;
    7878    }
    79    
     79
    8080    @Override
    8181    public void windowClosing(WindowEvent event) {
    … …  
    128128        }
    129129        /* dispose dialog */
    130         Main.pref.put("mapdust.addBug", true);
    131         Main.pref.put("mapdust.modify", false);
    132130        dialog.setVisible(false);
    133131        dialog.dispose();
    134         return;
    135132    }
     133
    136134}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteActionList.java

    r24514 r25127  
    7171    }
    7272
     73    /**
     74     * Uploads the content of the action list to the MapDust service.
     75     *
     76     * @param event The event which fires this action
     77     */
    7378    @Override
    7479    public void actionPerformed(ActionEvent event) {
    7580        if (event.getSource() instanceof JToggleButton) {
    76             // upload actions
    7781            try {
    7882                MapdustActionUploader.getInstance().uploadData(
    … …  
    8488                        tr("Error"), JOptionPane.ERROR_MESSAGE);
    8589            }
    86             Main.pref.put("mapdust.pluginState",
    87                     MapdustPluginState.ONLINE.getValue());
    88             getMapdustGUI().getPanel().getBtnPanel().getBtnRefresh()
    89                     .setEnabled(true);
     90            Main.pref.put("mapdust.pluginState", MapdustPluginState.ONLINE.getValue());
     91            getMapdustGUI().getPanel().getBtnPanel().getBtnRefresh().setEnabled(true);
    9092            notifyObservers();
    9193        }
    … …  
    121123        Iterator<MapdustRefreshObserver> elements = this.observers.iterator();
    122124        while (elements.hasNext()) {
    123             (elements.next()).updateData();
     125            (elements.next()).refreshData();
    124126        }
    125127    }
     128
    126129}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteAddBug.java

    r24514 r25127  
    8282    public ExecuteAddBug() {}
    8383
    84     /***
     84    /**
    8585     * Builds a <code>ExecuteAddBug</code> object based on the given arguments.
    8686     *
    … …  
    9393    }
    9494
     95    /**
     96     * Creates a new <code>MapdustBug</code> object if the entered informations
     97     * are valid. Otherwise a corresponding warning message will be shown to the
     98     * user.
     99     *
     100     * @param event The action event which fires this action
     101     */
    95102    @Override
    96103    public void actionPerformed(ActionEvent event) {
    … …  
    115122                latlon = Main.map.mapView.getLatLon(p.x, p.y);
    116123            }
    117             MapdustBug bug =
    118                     new MapdustBug(latlon, type, commentText, nickname);
     124            MapdustBug bug = new MapdustBug(latlon, type, commentText, nickname);
    119125            String pluginState = Main.pref.get("mapdust.pluginState");
    120126            if (pluginState.equals(MapdustPluginState.OFFLINE.getValue())) {
    … …  
    123129                bug.setStatus(Status.OPEN);
    124130                String iconPath = getIconPath(bug);
    125                 MapdustAction mapdustAction =
    126                         new MapdustAction(MapdustServiceCommand.ADD_BUG,
    127                                 iconPath, bug);
     131                MapdustAction mapdustAction = new MapdustAction(
     132                        MapdustServiceCommand.ADD_BUG, iconPath, bug);
    128133                if (getMapdustGUI().getQueuePanel() != null) {
    129134                    notifyObservers(mapdustAction);
    … …  
    138143                } catch (MapdustServiceHandlerException e) {
    139144                    errorMessage = "There was a Mapdust service error.";
    140                     JOptionPane.showMessageDialog(Main.parent,
    141                             tr(errorMessage), tr("Error"),
    142                             JOptionPane.ERROR_MESSAGE);
     145                    JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
     146                            tr("Error"), JOptionPane.ERROR_MESSAGE);
    143147                }
    144148                if (id != null) {
    … …  
    149153                    } catch (MapdustServiceHandlerException e) {
    150154                        errorMessage = "There was a Mapdust service error.";
    151                         JOptionPane.showMessageDialog(Main.parent,
    152                                 tr(errorMessage), tr("Error"),
    153                                 JOptionPane.ERROR_MESSAGE);
     155                        JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
     156                                tr("Error"), JOptionPane.ERROR_MESSAGE);
    154157                    }
    155158                    if (newMapdustBug != null) {
    … …  
    159162                resetSelectedBug(0);
    160163            }
    161             Main.pref.put("mapdust.modify", false);
    162164            /* destroy dialog */
    163165            getDialog().dispose();
     166            return;
    164167        }
    165168    }

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteCancel.java

    r24821 r25127  
    6565    }
    6666
    67 
     67    /**
     68     * Cancels the executed action, and closes the visible dialog window.
     69     *
     70     * @param event The action event which fires this action
     71     */
    6872    @Override
    6973    public void actionPerformed(ActionEvent event) {
    … …  
    7276            String status = Main.pref.get("selectedBug.status");
    7377            /* enable buttons */
    74             MapdustButtonPanel btnPanel =
    75                     getMapdustGUI().getPanel().getBtnPanel();
     78            MapdustButtonPanel btnPanel = getMapdustGUI().getPanel().getBtnPanel();
    7679            if (btnPanel != null) {
    7780                btnPanel.getBtnWorkOffline().setEnabled(true);
    … …  
    119122        }
    120123
    121         Main.pref.put("mapdust.addBug", true);
    122         Main.pref.put("mapdust.modify", false);
    123124        /* dispose dialog */
    124         getDialog().setVisible(false);
    125125        getDialog().dispose();
    126126    }
    127    
     127
    128128}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteCloseBug.java

    r24514 r25127  
    5555 * Fixes the given <code>MapdustBug</code> object. Validates the input data, and
    5656 * based on the plugin state executes the corresponding action. If the plugin is
    57  * in the "ONLINE" state then executes the Mapdust Service 'changeBugStatus'
     57 * in the "ONLINE" state then executes the MapDust Service 'changeBugStatus'
    5858 * action with statusId=2 and the given input parameters. If the plugin is in
    5959 * the "OFFLINE" state then adds the given action to the queue list.
    … …  
    9292    }
    9393
     94    /**
     95     * Closes the given MapDust bug. If the entered informations are invalid a
     96     * corresponding warning message will be displayed.
     97     *
     98     * @param event The action event which fires this action
     99     */
    94100    @Override
    95101    public void actionPerformed(ActionEvent event) {
    … …  
    107113                    /* invalid input data */
    108114                    JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
    109                            tr("Missing input data"), JOptionPane.WARNING_MESSAGE);
     115                            tr("Missing input data"), JOptionPane.WARNING_MESSAGE);
    110116                    return;
    111117                }
    … …  
    155161                enableFiredButton(issueDialog.getFiredButton());
    156162                resetSelectedBug(0);
    157                 Main.pref.put("mapdust.modify", false);
    158163                /* destroy dialog */
    159164                issueDialog.dispose();

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteCommentBug.java

    r24514 r25127  
    9191    }
    9292
     93    /**
     94     * Creates a comment for the given MapDust bug. If the entered informations
     95     * are invalid a corresponding warning message will be displayed.
     96     *
     97     * @param event The action event which fires this action
     98     */
    9399    @Override
    94100    public void actionPerformed(ActionEvent event) {
    … …  
    154160                enableFiredButton(issueDialog.getFiredButton());
    155161                resetSelectedBug(0);
    156                 Main.pref.put("mapdust.modify", false);
    157162                /* destroy dialog */
    158163                issueDialog.dispose();
    … …  
    228233        }
    229234    }
     235   
    230236}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteInvalidateBug.java

    r24514 r25127  
    9595    }
    9696
     97    /**
     98     * Invalidates the given MapDust bug. If the entered informations are
     99     * invalid a corresponding warning message will be displayed.
     100     *
     101     * @param event The action event which fires this action
     102     */
    97103    @Override
    98104    public void actionPerformed(ActionEvent event) {
    … …  
    101107            if (btn.getText().equals("OK")) {
    102108                /* ok button was pressed */
    103                 ChangeIssueStatusDialog issueDialog = (ChangeIssueStatusDialog) getDialog();
     109                ChangeIssueStatusDialog issueDialog =
     110                        (ChangeIssueStatusDialog) getDialog();
    104111                String nickname = issueDialog.getTxtNickname().getText();
    105112                String commentText = issueDialog.getTxtDescription().getText();
    … …  
    108115                if (errorMessage != null) {
    109116                    /* invalid input */
    110                     JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
     117                    JOptionPane.showMessageDialog(Main.parent, tr(errorMessage), 
    111118                            tr("Missing input data"), JOptionPane.WARNING_MESSAGE);
    112119                    return;
    … …  
    115122                Main.pref.put("mapdust.nickname", nickname);
    116123                MapdustBug selectedBug = getSelectedBug();
    117                 MapdustComment comment = new MapdustComment(selectedBug.getId(),
     124                MapdustComment comment = new MapdustComment(selectedBug.getId(), 
    118125                        commentText, nickname);
    119126                String pluginState = Main.pref.get("mapdust.pluginState");
    … …  
    123130                    String iconPath = getIconPath(selectedBug);
    124131                    MapdustAction mapdustAction = new MapdustAction(
    125                             MapdustServiceCommand.CHANGE_BUG_STATUS, iconPath,
     132                            MapdustServiceCommand.CHANGE_BUG_STATUS, iconPath, 
    126133                            selectedBug, comment, 3);
    127134                    if (getMapdustGUI().getQueuePanel() != null) {
    … …  
    136143                    } catch (MapdustServiceHandlerException e) {
    137144                        errorMessage = "There was a Mapdust service error.";
    138                         JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
    139                                 tr("Error"), JOptionPane.ERROR_MESSAGE);
     145                        JOptionPane.showMessageDialog(Main.parent,
     146                                tr(errorMessage), tr("Error"),
     147                                JOptionPane.ERROR_MESSAGE);
    140148                    }
    141149                    if (id != null) {
    … …  
    143151                        MapdustBug newMapdustBug = null;
    144152                        try {
    145                             newMapdustBug = handler.getBug(selectedBug.getId(), null);
     153                            newMapdustBug = handler.getBug(selectedBug.getId(),
     154                                    null);
    146155                        } catch (MapdustServiceHandlerException e) {
    147156                            errorMessage = "There was a Mapdust service error.";
    148157                            errorMessage += "Mapdust bug report.";
    149                             JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
    150                                     tr("Error"), JOptionPane.ERROR_MESSAGE);
     158                            JOptionPane.showMessageDialog(Main.parent,
     159                                    tr(errorMessage), tr("Error"),
     160                                    JOptionPane.ERROR_MESSAGE);
    151161                        }
    152162                        if (newMapdustBug != null) {
    … …  
    158168                enableFiredButton(issueDialog.getFiredButton());
    159169                resetSelectedBug(0);
    160                 Main.pref.put("mapdust.modify", false);
    161170                /* destroy dialog */
    162171                issueDialog.dispose();

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteReOpenBug.java

    r24514 r25127  
    9494    }
    9595
     96    /**
     97     *
     98     * @param event The event which fires this action
     99     */
    96100    @Override
    97101    public void actionPerformed(ActionEvent event) {
    … …  
    165169                enableFiredButton(issueDialog.getFiredButton());
    166170                resetSelectedBug(0);
    167                 Main.pref.put("mapdust.modify", false);
    168171                /* destroy dialog */
    169172                issueDialog.dispose();
    … …  
    240243        }
    241244    }
     245   
    242246}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteRefresh.java

    r24514 r25127  
    3434import javax.swing.AbstractAction;
    3535import javax.swing.JToggleButton;
     36import org.openstreetmap.josm.Main;
    3637import org.openstreetmap.josm.plugins.mapdust.gui.observer.MapdustRefreshObservable;
    3738import org.openstreetmap.josm.plugins.mapdust.gui.observer.MapdustRefreshObserver;
    … …  
    6061    public ExecuteRefresh() {}
    6162
     63    /**
     64     * Updates the Mapdust data.
     65     *
     66     * @param event The event which fires this action
     67     */
    6268    @Override
    6369    public void actionPerformed(ActionEvent event) {
    … …  
    6571            JToggleButton btn = (JToggleButton) event.getSource();
    6672            /* update the bugs */
     73            Main.pref.put("mapdust.showError", true);
    6774            notifyObservers();
    6875            btn.setSelected(false);
    … …  
    99106        Iterator<MapdustRefreshObserver> elements = this.observers.iterator();
    100107        while (elements.hasNext()) {
    101             (elements.next()).updateData();
     108            (elements.next()).refreshData();
    102109        }
    103110    }
     111   
    104112}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/execute/ExecuteWorkOffline.java

    r24514 r25127  
    4646/**
    4747 * Executes the work offline action. In the offline mode the user actions will
    48  * not be uploaded immediately to the Mapdust service. The user can perform the
     48 * not be uploaded immediately to the MapDust service. The user can perform the
    4949 * following actions in offline mode: add bug, comment bug and change bug
    50  * status. After deactivating the offline mode the user's modifications will be
    51  * uploaded to the Mapdust service.
     50 * status. After de-activating the offline mode the user's modifications will be
     51 * uploaded to the MapDust service.
    5252 *
    5353 * @author Bea
    … …  
    7979    }
    8080
     81    /**
     82     * Sets the 'offline' mode for the plugin.
     83     *
     84     * @param event The event which fires this action
     85     */
    8186    @Override
    8287    public void actionPerformed(ActionEvent event) {
    … …  
    9499                    String message = "Do you want to submit your changes ";
    95100                    message += "to Mapdust?";
    96                     int result =
    97                             JOptionPane.showConfirmDialog(Main.parent,
    98                                     tr(message), tr(title),
    99                                     JOptionPane.YES_NO_OPTION);
     101                    int result = JOptionPane.showConfirmDialog(Main.parent,
     102                            tr(message), tr(title), JOptionPane.YES_NO_OPTION);
    100103                    if (result == JOptionPane.YES_OPTION) {
    101104                        // process data
    102105                        try {
    103106                            MapdustActionUploader.getInstance().uploadData(
    104                                     getMapdustGUI().getQueuePanel()
    105                                             .getActionList());
     107                                    getMapdustGUI().getQueuePanel().getActionList());
    106108                        } catch (MapdustActionUploaderException e) {
    107                             String errorMessage =
    108                                     "There was a Mapdust service error.";
     109                            String errorMessage = "There was a Mapdust service error.";
    109110                            JOptionPane.showMessageDialog(Main.parent,
    110111                                    tr(errorMessage), tr("Error"),
    … …  
    150151        Iterator<MapdustRefreshObserver> elements = this.observers.iterator();
    151152        while (elements.hasNext()) {
    152             (elements.next()).updateData();
     153            (elements.next()).refreshData();
    153154        }
    154155    }
     156   
    155157}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/show/MapdustShowAction.java

    r24514 r25127  
    141141    }
    142142
    143 
    144143    /**
    145144     * Disables the buttons from the given button panel.

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/show/ShowCloseBugAction.java

    r24514 r25127  
    3131import java.awt.event.ActionEvent;
    3232import javax.swing.JToggleButton;
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.plugins.mapdust.MapdustPlugin;
    3534import org.openstreetmap.josm.plugins.mapdust.gui.component.dialog.ChangeIssueStatusDialog;
    … …  
    7675            }
    7776            disableButtons(getButtonPanel());
    78             Main.pref.put("mapdust.modify", true);
    7977            ChangeIssueStatusDialog dialog = new ChangeIssueStatusDialog(
    8078                    getTitle(), getIconName(), getMessageText(), "close", btn,

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/show/ShowCommentBugAction.java

    r24514 r25127  
    3131import java.awt.event.ActionEvent;
    3232import javax.swing.JToggleButton;
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.plugins.mapdust.MapdustPlugin;
    3534import org.openstreetmap.josm.plugins.mapdust.gui.component.dialog.CommentIssueDialog;
    … …  
    7776            }
    7877            disableButtons(getButtonPanel());
    79             Main.pref.put("mapdust.modify", true);
    8078            CommentIssueDialog dialog = new CommentIssueDialog(getTitle(),
    8179                    getIconName(), getMessageText(), btn, getMapdustPlugin());

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/show/ShowInvalidateBugAction.java

    r24514 r25127  
    3131import java.awt.event.ActionEvent;
    3232import javax.swing.JToggleButton;
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.plugins.mapdust.MapdustPlugin;
    3534import org.openstreetmap.josm.plugins.mapdust.gui.component.dialog.ChangeIssueStatusDialog;
    … …  
    7776            }
    7877            disableButtons(getButtonPanel());
    79             Main.pref.put("mapdust.modify", true);
    8078            ChangeIssueStatusDialog dialog = new ChangeIssueStatusDialog(
    8179                    getTitle(), getIconName(), getMessageText(), "invalidate",

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/action/show/ShowReOpenBugAction.java

    r24514 r25127  
    3131import java.awt.event.ActionEvent;
    3232import javax.swing.JToggleButton;
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.plugins.mapdust.MapdustPlugin;
    3534import org.openstreetmap.josm.plugins.mapdust.gui.component.dialog.ChangeIssueStatusDialog;
    … …  
    7675            }
    7776            disableButtons(getButtonPanel());
    78             Main.pref.put("mapdust.modify", true);
    7977            ChangeIssueStatusDialog dialog = new ChangeIssueStatusDialog(
    8078                    getTitle(), getIconName(), getMessageText(), "reopen", btn,

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/dialog/ChangeIssueStatusDialog.java

    r24514 r25127  
    126126        setLayout(null);
    127127        addComponents(mapdustPlugin);
    128         MapdustButtonPanel btnPanel =
    129                 mapdustPlugin.getMapdustGUI().getPanel().getBtnPanel();
     128        MapdustButtonPanel btnPanel = mapdustPlugin.getMapdustGUI().getPanel().getBtnPanel();
    130129        addWindowListener(new WindowClose(this, btnPanel, getFiredButton()));
    131130    }
    … …  
    201200        /* creates the cancel button */
    202201        if (btnCancel == null) {
    203             Rectangle bounds = new Rectangle(250, 170, 80, 25);
     202            Rectangle bounds = new Rectangle(240, 170, 90, 25);
    204203            btnCancel = ComponentUtil.createJButton("Cancel", bounds, cancelAction);
    205204        }
    206205        /* creates the ok button */
    207206        if (btnOk == null) {
    208             Rectangle bounds = new Rectangle(180, 170, 60, 25);
     207            Rectangle bounds = new Rectangle(170, 170, 60, 25);
    209208            btnOk = ComponentUtil.createJButton("OK", bounds, okAction);
    210209        }

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/dialog/CommentIssueDialog.java

    r24514 r25127  
    166166        /* creates the cancel button */
    167167        if (btnCancel == null) {
    168             Rectangle bounds = new Rectangle(250, 170, 80, 25);
     168            Rectangle bounds = new Rectangle(240, 170, 90, 25);
    169169            ExecuteCancel cancelAction = new ExecuteCancel(this,
    170170                    mapdustPlugin.getMapdustGUI());
    … …  
    174174        /* creates the ok button */
    175175        if (btnOk == null) {
    176             Rectangle bounds = new Rectangle(180, 170, 60, 25);
     176            Rectangle bounds = new Rectangle(170, 170, 60, 25);
    177177            ExecuteCommentBug okAction =
    178178                    new ExecuteCommentBug(this, mapdustPlugin.getMapdustGUI());
    … …  
    272272        return messageText;
    273273    }
     274   
    274275}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/dialog/CreateIssueDialog.java

    r24514 r25127  
    6666
    6767    /** The create issue text */
    68     private final String createIssueText;
     68    private String createIssueText;
    6969
    7070    /** Text message */
    … …  
    111111     * @param mapdustPlugin The <code>MapdustPlugin</code> object
    112112     */
    113     public CreateIssueDialog(String title, String iconName, String messageText,
    114             Point point, MapdustPlugin mapdustPlugin) {
    115         this.createIssueText = messageText;
     113    public CreateIssueDialog(Point point, MapdustPlugin mapdustPlugin) {
     114        this.createIssueText= "In order to create a new bug report you";
     115        this.createIssueText += " need to provide your nickname and a brief";
     116        this.createIssueText+= " description for the bug.";
    116117        this.point = point;
    117         setTitle(title);
    118         setDefaultLookAndFeelDecorated(true);
    119         Image image = ImageProvider.get(iconName).getImage();
     118        /* set JDialog settings */
     119        initializeDialog();
     120        /* add components to the dialog */
     121        addComponents(mapdustPlugin);
     122        /* add window listenet */
     123        MapdustButtonPanel btnPanel = mapdustPlugin.getMapdustGUI().getPanel().getBtnPanel();
     124        addWindowListener(new WindowClose(this, btnPanel, null));
     125    }
     126
     127    /**
     128     * Initializes the dialog default fields.
     129     */
     130    private void initializeDialog(){
     131        /* set JDialog settings */
     132        setTitle("Create bug report");
     133        setModal(true);
     134        Image image = ImageProvider.get("dialogs/open.png").getImage();
    120135        setIconImage(image);
    121         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
     136        setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
    122137        getContentPane().setFont(new Font("Times New Roman", Font.BOLD, 14));
    123138        setResizable(false);
    124139        setForeground(Color.black);
    125140        setLayout(null);
    126         setModal(true);
    127         addComponents(mapdustPlugin);
    128         MapdustButtonPanel btnPanel = mapdustPlugin.getMapdustGUI().getPanel().getBtnPanel();
    129         addWindowListener(new WindowClose(this, btnPanel, getFiredButton()));
     141
     142    }
     143
     144    /**
     145     * Displays the dialog.
     146     */
     147    public void showDialog(){
     148       setLocationRelativeTo(null);
     149       getContentPane().setPreferredSize(getSize());
     150       pack();
     151       setVisible(true);
    130152    }
    131153
    … …  
    167189        if (lblDescription == null) {
    168190            lblDescription = ComponentUtil.createJLabel("Description", font,
    169                     new Rectangle(10, 150, 85, 25));
     191                    new Rectangle(10, 150, 95, 25));
    170192        }
    171193        if (cmpDescription == null) {
    … …  
    178200        /* creates the cancel button */
    179201        if (btnCancel == null) {
    180             Rectangle bounds = new Rectangle(260, 210, 80, 25);
     202            Rectangle bounds = new Rectangle(250, 210, 90, 25);
    181203            ExecuteCancel cancelAction = new ExecuteCancel(this,
    182204                    mapdustPlugin.getMapdustGUI());
    … …  
    186208        /* creates the ok button */
    187209        if (btnOk == null) {
    188             Rectangle bounds = new Rectangle(190, 210, 60, 25);
     210            Rectangle bounds = new Rectangle(180, 210, 60, 25);
    189211            ExecuteAddBug okAction = new ExecuteAddBug(this,
    190212                    mapdustPlugin.getMapdustGUI());
    … …  
    286308        return point;
    287309    }
     310
    288311}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/panel/MapdustBugPropertiesPanel.java

    r24514 r25127  
    2929
    3030
     31import static org.openstreetmap.josm.tools.I18n.tr;
    3132import java.awt.BorderLayout;
    3233import java.awt.Dimension;
     34import javax.swing.JOptionPane;
    3335import javax.swing.JPanel;
    3436import javax.swing.JScrollPane;
    3537import javax.swing.JTabbedPane;
     38import org.openstreetmap.josm.Main;
    3639import org.openstreetmap.josm.data.coor.LatLon;
    3740import org.openstreetmap.josm.plugins.mapdust.gui.component.util.ComponentUtil;
    … …  
    9194    }
    9295
     96    /**
     97     * Displays the details of the given MapDust bug.
     98     *
     99     * @param mapdustBug The <code>MapdustBug</code> object
     100     */
    93101    @Override
    94102    public void showDetails(MapdustBug mapdustBug) {
    95         MapdustBug selectedBug=mapdustBug;
     103        MapdustBug selectedBug = mapdustBug;
    96104        if (mapdustBug != null) {
    97105            if (mapdustBug.getNumberOfComments() > 0) {
    … …  
    104112        if (mainPanel != null) {
    105113            index = mainPanel.getSelectedIndex();
    106             cmpDetails.remove(detailsPanel);
    107             mainPanel.remove(cmpDetails);
    108             mainPanel.remove(cmpAddress);
    109             mainPanel.remove(descriptionPanel);
    110             mainPanel.remove(commentsPanel);
    111             mainPanel.remove(helpPanel);
     114            if (mainPanel.getComponentCount() > 0) {
     115                mainPanel.remove(cmpDetails);
     116                mainPanel.remove(cmpAddress);
     117                mainPanel.remove(descriptionPanel);
     118                mainPanel.remove(commentsPanel);
     119                mainPanel.remove(helpPanel);
     120            }
    112121            remove(mainPanel);
    113122        }
    … …  
    143152        /* create details panel */
    144153        detailsPanel = new MapdustBugDetailsPanel(mapdustBug);
    145         cmpDetails =
    146                 ComponentUtil.createJScrollPane(detailsPanel, getBounds(),
    147                         getBackground(), true, true);
     154        cmpDetails = ComponentUtil.createJScrollPane(detailsPanel, getBounds(),
     155                getBackground(), true, true);
    148156        cmpDetails.setPreferredSize(new Dimension(100, 100));
    149157        cmpDetails.setName("Bug Details");
    … …  
    153161        LatLon coordinates = mapdustBug != null ? mapdustBug.getLatLon() : null;
    154162        addressPanel = new MapdustAddressPanel(address, coordinates);
    155         cmpAddress =
    156                 ComponentUtil.createJScrollPane(addressPanel, getBounds(),
    157                         getBackground(), true, true);
     163        cmpAddress = ComponentUtil.createJScrollPane(addressPanel, getBounds(),
     164                getBackground(), true, true);
    158165        cmpAddress.setName("Address");
    159166        cmpAddress.setPreferredSize(new Dimension(100, 100));
    160167
    161168        /* create description panel */
    162         String description =
    163                 mapdustBug != null ? mapdustBug.getDescription() : "";
     169        String description = mapdustBug != null ? mapdustBug.getDescription() : "";
    164170        descriptionPanel = new MapdustDescriptionPanel(description);
    165171
    166172        /* create comments panel */
    167         MapdustComment[] comments =
    168                 mapdustBug != null ? mapdustBug.getComments()
    169                         : new MapdustComment[0];
     173        MapdustComment[] comments = mapdustBug != null ? mapdustBug.getComments()
     174                : new MapdustComment[0];
    170175        commentsPanel = new MapdustCommentsPanel(comments);
    171176
    … …  
    195200            bug = new MapdustServiceHandler().getBug(id, null);
    196201        } catch (MapdustServiceHandlerException e) {
    197 
     202            String errorMessage = "There was a MapDust service error durring ";
     203            errorMessage+=" the MapDust bug retrieve process.";
     204            JOptionPane.showMessageDialog(Main.parent, tr(errorMessage),
     205                    tr("Error"), JOptionPane.ERROR_MESSAGE);
    198206        }
    199207        return bug;

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/panel/MapdustCommentsPanel.java

    r24514 r25127  
    100100        add(sp);
    101101    }
     102
    102103}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/panel/MapdustPanel.java

    r24514 r25127  
    2929
    3030
    31 import static org.openstreetmap.josm.tools.I18n.tr;
    3231import java.awt.BorderLayout;
     32import java.awt.Color;
    3333import java.util.ArrayList;
    3434import java.util.Iterator;
    … …  
    3939import javax.swing.JPopupMenu;
    4040import javax.swing.JScrollPane;
     41import javax.swing.border.LineBorder;
    4142import javax.swing.event.ListSelectionEvent;
    4243import javax.swing.event.ListSelectionListener;
    … …  
    5051import org.openstreetmap.josm.plugins.mapdust.gui.action.show.ShowInvalidateBugAction;
    5152import org.openstreetmap.josm.plugins.mapdust.gui.action.show.ShowReOpenBugAction;
     53import org.openstreetmap.josm.plugins.mapdust.gui.component.renderer.BugListCellRenderer;
    5254import org.openstreetmap.josm.plugins.mapdust.gui.component.util.ComponentUtil;
    5355import org.openstreetmap.josm.plugins.mapdust.gui.observer.MapdustBugDetailsObservable;
    … …  
    102104     * Builds a <code>MapdustPlugin</code> object
    103105     */
    104     public MapdustPanel() {
    105 
    106     }
     106    public MapdustPanel() {}
    107107
    108108    /**
    … …  
    119119        setLayout(new BorderLayout(5, 10));
    120120        addComponents(mapdustPlugin);
    121         setName(tr(name));
     121        setName(name);
    122122    }
    123123
    … …  
    134134            /* add comment item */
    135135            MapdustShowAction action = new ShowCommentBugAction(mapdustPlugin);
    136             menuAddComment =
    137                     ComponentUtil.createJMenuItem(action, tr("Add comment"),
    138                             "dialogs/comment.png");
     136            menuAddComment = ComponentUtil.createJMenuItem(action, "Add comment",
     137                    "dialogs/comment.png");
    139138            menu.add(menuAddComment);
    140139            /* fix bug item */
    141140            action = new ShowCloseBugAction(mapdustPlugin);
    142             menuFixed =
    143                     ComponentUtil.createJMenuItem(action, tr("Close bug"),
    144                             "dialogs/fixed.png");
     141            menuFixed = ComponentUtil.createJMenuItem(action, "Close bug",
     142                    "dialogs/fixed.png");
    145143            menu.add(menuFixed);
    146144            /* invalidate bug item */
    147145            action = new ShowInvalidateBugAction(mapdustPlugin);
    148             menuInvalidate =
    149                     ComponentUtil.createJMenuItem(action, tr("Invalidate bug"),
    150                             "dialogs/invalid.png");
     146            menuInvalidate = ComponentUtil.createJMenuItem(action,
     147                    "Invalidate bug", "dialogs/invalid.png");
    151148            menu.add(menuInvalidate);
    152149            /* re-open bug item */
    153150            action = new ShowReOpenBugAction(mapdustPlugin);
    154             menuReopen =
    155                     ComponentUtil.createJMenuItem(action, tr("Re-open bug"),
    156                             "dialogs/reopen.png");
     151            menuReopen = ComponentUtil.createJMenuItem(action, "Re-open bug",
     152                    "dialogs/reopen.png");
    157153            menu.add(menuReopen);
    158154        }
    159155        /* create bugs list */
    160         listBugs = ComponentUtil.createJList(mapdustBugsList, menu);
    161         listBugs.addListSelectionListener(this);
    162         DisplayMenu adapter = new DisplayMenu(listBugs, menu);
    163         listBugs.addMouseListener(adapter);
    164         JScrollPane cmpBugs = ComponentUtil.createJScrollPane(listBugs);
    165         /* add components */
    166         add(cmpBugs, BorderLayout.CENTER);
     156        JScrollPane cmpBugs;
     157        if (mapdustBugsList != null && mapdustBugsList.size() == 0) {
     158            String text = " No bugs in the current view!";
     159            JList l=new JList(new String[]{text});
     160            l.setBorder(new LineBorder(Color.black, 1, false));
     161            l.setCellRenderer(new BugListCellRenderer());
     162            cmpBugs=ComponentUtil.createJScrollPane(l);
     163            add(cmpBugs, BorderLayout.CENTER);
     164        } else {
     165            listBugs = ComponentUtil.createJList(mapdustBugsList, menu);
     166            listBugs.addListSelectionListener(this);
     167            DisplayMenu adapter = new DisplayMenu(listBugs, menu);
     168            listBugs.addMouseListener(adapter);
     169            cmpBugs = ComponentUtil.createJScrollPane(getListBugs());
     170            add(cmpBugs, BorderLayout.CENTER);
     171        }
     172        /* add button panel */
    167173        add(btnPanel, BorderLayout.SOUTH);
    168174    }
    … …  
    203209            getMenuFixed().setEnabled(false);
    204210        }
     211        /* re-paint */
    205212        Main.map.mapView.repaint();
    206213        mapdustGUI.repaint();
    … …  
    213220     */
    214221    public MapdustBug getSelectedBug() {
    215         MapdustBug selectedBug = (MapdustBug) getListBugs().getSelectedValue();
     222        MapdustBug selectedBug=null;
     223        if (getListBugs()!=null) {
     224            selectedBug = (MapdustBug) getListBugs().getSelectedValue();
     225        }
    216226        return selectedBug;
    217227    }
    … …  
    348358        }
    349359    }
     360
    350361}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/component/renderer/BugListCellRenderer.java

    r24514 r25127  
    6363    public Component getListCellRendererComponent(JList list, Object value,
    6464            int index, boolean isSelected, boolean hasFocus) {
    65         JLabel label =
    66                 (JLabel) super.getListCellRendererComponent(list, value, index,
    67                         isSelected, hasFocus);
     65        JLabel label =(JLabel) super.getListCellRendererComponent(list, value,
     66                index,isSelected, hasFocus);
    6867        if (value instanceof MapdustBug) {
     68            /* show the MapdustBug in the list */
    6969            MapdustBug mapdustBug = (MapdustBug) value;
    7070            String iconPath = "bugs/normal/";
    … …  
    8787            label.setFont(new Font("Times New Roman", Font.BOLD, 12));
    8888        }
     89        if (value instanceof String){
     90            /* show default text in the list */
     91            String text=(String)value;
     92            label.setText(text);
     93            label.setFont(new Font("Times New Roman", Font.BOLD, 12));
     94        }
    8995        return (label);
    9096    }

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/observer/MapdustInitialUpdateObserver.java

    r24514 r25127  
    4242     */
    4343    public void initialUpdate();
     44
    4445}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/gui/observer/MapdustRefreshObserver.java

    r24514 r25127  
    3939
    4040    /**
    41      * Updates the data of the MapDust plugin data.
     41     * Refreshes the MapDust data. Downloads the bugs from the current view, and
     42     * updates the plugin with the new data.
    4243     */
    43     public void updateData();
     44    public void refreshData();
    4445}

  • applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/util/retry/RetrySetup.java

    r24514 r25127  
    3838    /** A default configuration for the {@link RetryAgent} */
    3939    public static final RetrySetup DEFAULT = new RetrySetup(RetryMode.COUNTED,
    40             3, 500);
     40            1, 500);
    4141
    4242    /** The retry mode */
Note: See TracChangeset for help on using the changeset viewer.