source: subversion/applications/editors/josm/plugins/mapdust/src/org/openstreetmap/josm/plugins/mapdust/MapdustPlugin.java

Last change on this file was 34528, checked in by donvip, 8 months ago

update to JOSM 14153

File size: 27.9 KB
Line 
1/* Copyright (c) 2010, skobbler GmbH
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice,
8 *    this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright notice,
10 *    this list of conditions and the following disclaimer in the documentation
11 *    and/or other materials provided with the distribution.
12 * 3. Neither the name of the project nor the names of its
13 *    contributors may be used to endorse or promote products derived from this
14 *    software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28package org.openstreetmap.josm.plugins.mapdust;
29
30import static org.openstreetmap.josm.tools.I18n.tr;
31
32import java.awt.Point;
33import java.awt.event.KeyEvent;
34import java.awt.event.MouseEvent;
35import java.awt.event.MouseListener;
36import java.util.ArrayList;
37import java.util.List;
38import java.util.concurrent.ArrayBlockingQueue;
39import java.util.concurrent.ThreadPoolExecutor;
40import java.util.concurrent.TimeUnit;
41
42import javax.swing.JOptionPane;
43import javax.swing.SwingUtilities;
44
45import org.openstreetmap.josm.data.Bounds;
46import org.openstreetmap.josm.data.UserIdentityManager;
47import org.openstreetmap.josm.gui.MainApplication;
48import org.openstreetmap.josm.gui.MapFrame;
49import org.openstreetmap.josm.gui.MapView;
50import org.openstreetmap.josm.gui.NavigatableComponent;
51import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
52import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
53import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
54import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
55import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
56import org.openstreetmap.josm.plugins.Plugin;
57import org.openstreetmap.josm.plugins.PluginInformation;
58import org.openstreetmap.josm.plugins.mapdust.gui.MapdustGUI;
59import org.openstreetmap.josm.plugins.mapdust.gui.component.dialog.CreateBugDialog;
60import org.openstreetmap.josm.plugins.mapdust.gui.observer.MapdustBugObserver;
61import org.openstreetmap.josm.plugins.mapdust.gui.observer.MapdustUpdateObserver;
62import org.openstreetmap.josm.plugins.mapdust.gui.value.MapdustPluginState;
63import org.openstreetmap.josm.plugins.mapdust.service.MapdustServiceHandler;
64import org.openstreetmap.josm.plugins.mapdust.service.MapdustServiceHandlerException;
65import org.openstreetmap.josm.plugins.mapdust.service.value.BoundingBox;
66import org.openstreetmap.josm.plugins.mapdust.service.value.MapdustBug;
67import org.openstreetmap.josm.plugins.mapdust.service.value.MapdustBugFilter;
68import org.openstreetmap.josm.plugins.mapdust.service.value.MapdustRelevance;
69import org.openstreetmap.josm.spi.preferences.Config;
70import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent;
71import org.openstreetmap.josm.spi.preferences.PreferenceChangedListener;
72import org.openstreetmap.josm.tools.Shortcut;
73
74/**
75 * This is the main class of the MapDust plug-in. Defines the MapDust plug-in
76 * main functionality.
77 *
78 * @author Bea
79 */
80public class MapdustPlugin extends Plugin implements LayerChangeListener,
81        ZoomChangeListener, PreferenceChangedListener, MouseListener,
82        MapdustUpdateObserver, MapdustBugObserver {
83
84    /** Executor that will run the updates. */
85    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
86      3, 5, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardPolicy());
87
88    /** The graphical user interface of the plug-in */
89    private MapdustGUI mapdustGUI;
90
91    /** The layer of the MapDust plug-in */
92    private MapdustLayer mapdustLayer;
93
94    /** The <code>CreateIssueDialog</code> object */
95    private CreateBugDialog dialog;
96
97    /** The list of <code>MapdustBug</code> objects */
98    private List<MapdustBug> mapdustBugList;
99
100    /** The bounding box from where the MapDust bugs are down-loaded */
101    private BoundingBox bBox;
102   
103    /** The shortcut to access MapDust GUI */
104    private Shortcut shortcut;
105
106    /**
107     * The <code>MapdustBugFilter</code> object representing the selected
108     * filters
109     */
110    private MapdustBugFilter filter;
111
112    /** Specifies if there was or not an error down-loading the data */
113    protected boolean wasError = false;
114
115    /**
116     * Builds a new <code>MapDustPlugin</code> object based on the given
117     * arguments.
118     *
119     * @param info The <code>MapDustPlugin</code> object
120     */
121    public MapdustPlugin(PluginInformation info) {
122        super(info);
123        this.filter = null;
124        this.bBox = null;
125        initializePlugin();
126    }
127
128    /**
129     * Initialize the <code>MapdustPlugin</code> object. Creates the
130     * <code>MapdustGUI</code> and initializes the following variables with
131     * default values: 'mapdust.pluginState', 'mapdust.nickname',
132     * 'mapdust.showError', 'mapdust.version' and 'mapdust.localVersion'.
133     */
134    private void initializePlugin() {
135        /* create MapDust Shortcut */
136        this.shortcut = Shortcut.registerShortcut("MapDust", tr("Toggle: {0}", tr("Open MapDust")),
137                KeyEvent.VK_0, Shortcut.ALT_SHIFT);
138        /* add default values for static variables */
139        Config.getPref().put("mapdust.pluginState", MapdustPluginState.ONLINE.getValue());
140        Config.getPref().put("mapdust.nickname", "");
141        Config.getPref().putBoolean("mapdust.showError", true);
142        Config.getPref().put("mapdust.version", getPluginInformation().version);
143        Config.getPref().put("mapdust.localVersion", getPluginInformation().localversion);
144        Config.getPref().addPreferenceChangeListener(this);
145    }
146
147    /**
148     * Initializes the new <code>MapFrame</code>. Adds the
149     * <code>MapdustGUI</code> to the new <code>MapFrame</code> and sets the
150     * observers/listeners.
151     *
152     * @param oldMapFrame The old <code>MapFrame</code> object
153     * @param newMapFrame The new <code>MapFrame</code> object
154     */
155    @Override
156    public void mapFrameInitialized(MapFrame oldMapFrame, MapFrame newMapFrame) {
157        if (newMapFrame != null) {
158            /* add MapDust dialog window */
159            mapdustGUI = new MapdustGUI(tr("MapDust bug reports"), "mapdust_icon.png", 
160                    tr("Activates the MapDust bug reporter plugin"), shortcut, 150, this);
161            /* add MapdustGUI */
162            mapdustGUI.setBounds(newMapFrame.getBounds());
163            mapdustGUI.addObserver(this);
164            newMapFrame.addToggleDialog(mapdustGUI);
165            /* add Listeners */
166            NavigatableComponent.addZoomChangeListener(this);
167            MainApplication.getLayerManager().addLayerChangeListener(this);
168            newMapFrame.mapView.addMouseListener(this);
169            /* put username to preferences */
170            Config.getPref().put("mapdust.josmUserName", UserIdentityManager.getInstance().getUserName());
171        } else {
172            /* if new MapFrame is null, remove listener */
173            oldMapFrame.mapView.removeMouseListener(this);
174            MainApplication.getLayerManager().removeLayerChangeListener(this);
175            NavigatableComponent.removeZoomChangeListener(this);
176            mapdustGUI.removeObserver(this);
177            mapdustGUI = null;
178        }
179    }
180
181    /**
182     * Listens for the events of type <code>PreferenceChangeEvent</code> . If
183     * the event key is 'osm-server.username' then if the user name was changed
184     * in Preferences and it was used as 'nickname'( the user did not changed
185     * this completed nickname to something else ) for submitting changes to
186     * MapDust , re-set the 'mapdust.josmUserName' and 'mapdust.nickname'
187     * properties.
188     *
189     * @param event The <code>PreferenceChangeEvent</code> object
190     */
191    @Override
192    public void preferenceChanged(PreferenceChangeEvent event) {
193        if (mapdustGUI != null && mapdustGUI.isShowing() && !wasError && mapdustLayer != null
194                && mapdustLayer.isVisible()) {
195            if (event.getKey().equals("osm-server.username")) {
196                String newUserName = UserIdentityManager.getInstance().getUserName();
197                String oldUserName = Config.getPref().get("mapdust.josmUserName");
198                String nickname = Config.getPref().get("mapdust.nickname");
199                if (nickname.isEmpty()) {
200                    /* nickname was not completed */
201                    Config.getPref().put("mapdust.josmUserName", newUserName);
202                    Config.getPref().put("mapdust.nickname", newUserName);
203                } else {
204                    if (nickname.equals(oldUserName)) {
205                        /* user name was used for nickname, and was not changed */
206                        Config.getPref().put("mapdust.josmUserName", newUserName);
207                        Config.getPref().put("mapdust.nickname", newUserName);
208                    } else {
209                        /* user name was used for nickname, and was changed */
210                        Config.getPref().put("mapdust.josmUserName", newUserName);
211                    }
212                }
213            }
214        }
215    }
216
217    /**
218     * Updates the map and the MapDust bugs list with the given
219     * <code>MapdustBug</code> object. If the bug is already contained in the
220     * list and map, then this object will be updated with the new properties.
221     * If the filter settings does not allow this new bug to be shown in the map
222     * and list, then it will be removed from the map and list.
223     *
224     * @param mapdustBug The <code>MapdustBug</code> object
225     */
226    @Override
227    public synchronized void changedData(MapdustBug mapdustBug) {
228        if (mapdustBugList == null) {
229            mapdustBugList = new ArrayList<>();
230        }
231        if (getMapdustGUI().isDialogShowing()) {
232            if (MainApplication.getMap() != null && MainApplication.getMap().mapView != null) {
233                MapdustBug oldBug = null;
234                for (MapdustBug bug : mapdustBugList) {
235                    if (bug.getId().equals(mapdustBug.getId())) {
236                        oldBug = bug;
237                    }
238                }
239                boolean showBug = shouldDisplay(mapdustBug);
240                if (oldBug != null) {
241                    /* remove, add */
242                    if (showBug) {
243                        mapdustBugList.remove(oldBug);
244                        mapdustBugList.add(0, mapdustBug);
245                    } else {
246                        mapdustBugList.remove(oldBug);
247                    }
248                } else {
249                    /* new add */
250                    if (showBug) {
251                        mapdustBugList.add(0, mapdustBug);
252                    }
253                }
254                mapdustGUI.update(mapdustBugList, this);
255                mapdustLayer.setMapdustGUI(mapdustGUI);
256                if (showBug) {
257                    mapdustGUI.setSelectedBug(mapdustBugList.get(0));
258                } else {
259                    mapdustLayer.setBugSelected(null);
260                    mapdustGUI.enableBtnPanel(true);
261                    MainApplication.getMap().mapView.repaint();
262                    String title = "MapDust";
263                    String message = "The operation was successful.";
264                    JOptionPane.showMessageDialog(MainApplication.getMainFrame(), message, title,
265                            JOptionPane.INFORMATION_MESSAGE);
266                }
267            }
268        }
269    }
270
271    /**
272     * Verifies if the given <code>MapdustBug</code> object should be displayed
273     * on the map and on the bugs list. A <code>MapdustBug</code> will be
274     * displayed on the map only if it is permitted by the selected filter
275     * settings (statuses, types, description and relevance filter).
276     *
277     * @param mapdustBug The <code>MapdustBug</code> object
278     * @return true if the given bug should be displayed false otherwise
279     */
280    private boolean shouldDisplay(MapdustBug mapdustBug) {
281        boolean result = true;
282        if (filter != null) {
283            boolean containsStatus = false;
284            if (filter.getStatuses() != null && !filter.getStatuses().isEmpty()) {
285                Integer statusKey = mapdustBug.getStatus().getKey();
286                if (filter.getStatuses().contains(statusKey)) {
287                    containsStatus = true;
288                }
289            } else {
290                containsStatus = true;
291            }
292            boolean containsType = false;
293            if (filter.getTypes() != null && !filter.getTypes().isEmpty()) {
294                String typeKey = mapdustBug.getType().getKey();
295                if (filter.getTypes().contains(typeKey)) {
296                    containsType = true;
297                }
298            } else {
299                containsType = true;
300            }
301            if (filter.getDescr() != null && filter.getDescr()) {
302                /* show only bugs with isDefaultDescription = false */
303                if (mapdustBug.getIsDefaultDescription()) {
304                    result = false;
305                } else {
306                    result = containsStatus && containsType;
307                }
308            } else {
309                result = containsStatus && containsType;
310            }
311            /* check relevance filter settings */
312            boolean containsMinRelevance = false;
313            if (filter.getMinRelevance() != null) {
314                MapdustRelevance minRel = filter.getMinRelevance();
315                MapdustRelevance bugRel = mapdustBug.getRelevance();
316                if (minRel.equals(bugRel)) {
317                    containsMinRelevance = true;
318                } else {
319                    if (bugRel.compareTo(minRel) == 1) {
320                        containsMinRelevance = true;
321                    }
322                }
323            }
324            boolean containsMaxRelevance = false;
325            if (filter.getMaxRelevance() != null) {
326                MapdustRelevance maxRel = filter.getMaxRelevance();
327                MapdustRelevance bugRel = mapdustBug.getRelevance();
328                if (maxRel.equals(bugRel)) {
329                    containsMaxRelevance = true;
330                } else {
331                    if (bugRel.compareTo(maxRel) == -1) {
332                        containsMaxRelevance = true;
333                    }
334                }
335                result = result && (containsMinRelevance && containsMaxRelevance);
336            }
337        }
338        return result;
339    }
340
341    /**
342     * No need to implement this.
343     */
344    @Override
345    public void mouseEntered(MouseEvent event) {}
346
347    /**
348     * No need to implement this.
349     */
350    @Override
351    public void mouseExited(MouseEvent arg0) {}
352
353    /**
354     * No need to implement this.
355     */
356    @Override
357    public void mousePressed(MouseEvent event) {}
358
359    /**
360     * No need to implement this.
361     */
362    @Override
363    public void mouseReleased(MouseEvent arg0) {}
364
365    /**
366     * At mouse click the following two actions can be done: adding a new bug,
367     * and selecting a bug from the map. A bug can be added if the plug-in is
368     * the only active plug-in and you double click on the map. You can select
369     * a bug from the map by clicking on it.
370     *
371     * @param event The <code>MouseEvent</code> object
372     */
373    @Override
374    public void mouseClicked(MouseEvent event) {
375        if (mapdustLayer != null && mapdustLayer.isVisible()) {
376            if (event.getButton() == MouseEvent.BUTTON1) {
377                if (event.getClickCount() == 2 && !event.isConsumed()) {
378                    if (MainApplication.getLayerManager().getActiveLayer() == getMapdustLayer()) {
379                        /* show add bug dialog */
380                        MapdustBug bug = mapdustGUI.getSelectedBug();
381                        if (bug != null) {
382                            Config.getPref().put("selectedBug.status", bug.getStatus()
383                                    .getValue());
384                        } else {
385                            Config.getPref().put("selectedBug.status", "create");
386                        }
387                        /* disable MapdustButtonPanel */
388                        mapdustGUI.getPanel().disableBtnPanel();
389                        /* create and show dialog */
390                        dialog = new CreateBugDialog(event.getPoint(), this);
391                        dialog.showDialog();
392                        event.consume();
393                        return;
394                    }
395                }
396                if (event.getClickCount() == 1 && !event.isConsumed()) {
397                    /* allow click on the bug icon on the map */
398                    Point p = event.getPoint();
399                    MapdustBug nearestBug = getNearestBug(p);
400                    if (nearestBug != null) {
401                        mapdustLayer.setBugSelected(nearestBug);
402                        /* set also in the list of bugs the element */
403                        mapdustGUI.setSelectedBug(nearestBug);
404                        MainApplication.getMap().mapView.repaint();
405                    }
406                    return;
407                }
408            }
409        }
410    }
411
412    /**
413     * Returns the nearest <code>MapdustBug</code> object to the given point on
414     * the map.
415     *
416     * @param p A <code>Point</code> object
417     * @return A <code>MapdustBug</code> object
418     */
419    private MapdustBug getNearestBug(Point p) {
420        double snapDistance = 10;
421        double minDistanceSq = Double.MAX_VALUE;
422        MapdustBug nearestBug = null;
423        for (MapdustBug bug : mapdustBugList) {
424            Point sp = MainApplication.getMap().mapView.getPoint(bug.getLatLon());
425            double dist = p.distanceSq(sp);
426            if (minDistanceSq > dist && p.distance(sp) < snapDistance) {
427                minDistanceSq = p.distanceSq(sp);
428                nearestBug = bug;
429            } else if (minDistanceSq == dist) {
430                nearestBug = bug;
431            }
432        }
433        return nearestBug;
434    }
435
436    @Override
437    public void layerOrderChanged(LayerOrderChangeEvent e) {
438    }
439
440    /**
441     * Adds the <code>MapdustLayer</code> to the JOSM editor. If the list of
442     * <code>MapdustBug</code>s is null then down-loads the data from the
443     * MapDust Service and updates the editor with this new data.
444     *
445     * @param e The new added layer event
446     */
447    @Override
448    public void layerAdded(LayerAddEvent e) {}
449
450    /**
451     * Removes the <code>MapdustLayer</code> from the JOSM editor. Also closes
452     * the MapDust plug-in window.
453     *
454     * @param e The new added layer event
455     */
456    @Override
457    public void layerRemoving(LayerRemoveEvent e) {
458        if (e.getRemovedLayer() instanceof MapdustLayer) {
459            /* remove the layer */
460            Config.getPref().put("mapdust.pluginState",
461                    MapdustPluginState.ONLINE.getValue());
462            NavigatableComponent.removeZoomChangeListener(this);
463            if (mapdustGUI != null) {
464                MainApplication.getMap().remove(mapdustGUI);
465                mapdustGUI.destroy();
466            }
467            mapdustLayer = null;
468            filter = null;
469            mapdustBugList = null;
470        }
471    }
472
473    /**
474     * Listens for the zoom change event. If the zoom was changed, then it will
475     * down-load the MapDust bugs data from the current view. The new data will
476     * be down-loaded only if the current bounding box is different from the
477     * previous one.
478     */
479    @Override
480    public void zoomChanged() {
481        if (mapdustGUI != null && mapdustGUI.isShowing() && !wasError) {
482            boolean download = true;
483            BoundingBox curentBBox = getBBox();
484            if (bBox != null) {
485                if (bBox.equals(curentBBox)) {
486                    download = false;
487                }
488            }
489            bBox = curentBBox;
490            if (download) {
491                updatePluginData();
492            }
493        }
494    }
495
496    /**
497     * Updates the plug-in with a new MapDust bugs data. If the filters are set
498     * then the MapDust data will be filtered. If initialUpdate flag is true
499     * then the plug-in is updated for the first time with the MapDust data. By
500     * default the first time there is no filter applied to the MapDust data.
501     *
502     * @param filter The <code>MapdustBugFilter</code> containing the filter
503     * settings
504     * @param initialUpdate If true then there will be no filter applied.
505     */
506    @Override
507    public void update(MapdustBugFilter filter, boolean initialUpdate) {
508        bBox = getBBox();
509        if (initialUpdate) {
510            updatePluginData();
511        } else {
512            if (filter != null) {
513                this.filter = filter;
514            }
515            if (mapdustGUI != null && mapdustGUI.isShowing() && !wasError) {
516                updatePluginData();
517            }
518        }
519    }
520
521    /**
522     * Returns the current bounding box. If the bounding box values are not in
523     * the limits, then it will normalized.
524     *
525     * @return A <code>BoundingBox</code>
526     */
527    private BoundingBox getBBox() {
528        MapView mapView = MainApplication.getMap().mapView;
529        Bounds bounds = new Bounds(mapView.getLatLon(0, mapView.getHeight()),
530                mapView.getLatLon(mapView.getWidth(), 0));
531        return new BoundingBox(bounds.getMin().lon(), bounds.getMin().lat(),
532                bounds.getMax().lon(), bounds.getMax().lat());
533    }
534
535    /**
536     * Updates the <code>MapdustPlugin</code> data. Down-loads the
537     * <code>MapdustBug</code> objects from the current view, and updates the
538     * <code>MapdustGUI</code> and the map with the new data.
539     */
540    private void updatePluginData() {
541        executor.execute(() -> updateMapdustData());
542    }
543
544    /**
545     * Updates the MapDust plug-in data. Down-loads the list of
546     * <code>MapdustBug</code> objects for the given area, and updates the map
547     * and the MapDust layer with the new data.
548     */
549    protected synchronized void updateMapdustData() {
550        if (MainApplication.getMap() != null && MainApplication.getMap().mapView != null) {
551            /* Downloads the MapDust data */
552            try {
553                MapdustServiceHandler handler = new MapdustServiceHandler();
554                mapdustBugList = handler.getBugs(bBox, filter);
555                wasError = false;
556            } catch (MapdustServiceHandlerException e) {
557                wasError = true;
558                mapdustBugList = new ArrayList<>();
559            }
560            /* update the view */
561            SwingUtilities.invokeLater(new Runnable() {
562                @Override
563                public void run() {
564                    synchronized (this) {
565                        updateView();
566                        if (wasError) {
567                            handleError();
568                        }
569                    }
570                }
571            });
572        }
573    }
574
575    /**
576     * Updates the current view ( map and MapDust bug list), with the given list
577     * of <code>MapdustBug</code> objects.
578     */
579    protected void updateView() {
580        if (MainApplication.getMap() != null && MainApplication.getMap().mapView != null) {
581            /* update the MapdustLayer */
582            boolean needRepaint = false;
583            if (!containsMapdustLayer()) {
584                /* first start or layer was deleted */
585                if (mapdustGUI.isDownloaded()) {
586                    mapdustGUI.update(mapdustBugList, this);
587                    /* create and add the layer */
588                    mapdustLayer = new MapdustLayer("MapDust", mapdustGUI,
589                            mapdustBugList);
590                    MainApplication.getLayerManager().addLayer(this.mapdustLayer);
591                    MainApplication.getMap().mapView.moveLayer(this.mapdustLayer, 0);
592                    MainApplication.getMap().mapView.addMouseListener(this);
593                    NavigatableComponent.addZoomChangeListener(this);
594                    needRepaint = true;
595                }
596            } else {
597                if (mapdustLayer != null) {
598                    /* MapDust data was changed */
599                    mapdustGUI.update(mapdustBugList, this);
600                    mapdustLayer.invalidate();
601                    mapdustLayer.update(mapdustGUI, mapdustBugList);
602                    needRepaint = true;
603                }
604            }
605            if (needRepaint) {
606                /* force repaint */
607                mapdustGUI.revalidate();
608                MainApplication.getMap().mapView.revalidate();
609                MainApplication.getMap().repaint();
610            }
611        }
612    }
613
614    /**
615     * Verifies if the <code>MapView</code> contains or not the
616     * <code>MapdustLayer</code> layer.
617     *
618     * @return true if the <code>MapView</code> contains the
619     * <code>MapdustLayer</code> false otherwise
620     */
621    private boolean containsMapdustLayer() {
622        return mapdustLayer != null && MainApplication.getLayerManager().containsLayer(mapdustLayer);
623    }
624
625    /**
626     * Handles the <code>MapdustServiceHandlerException</code> error.
627     */
628    protected void handleError() {
629        String showMessage = Config.getPref().get("mapdust.showError");
630        Boolean showErrorMessage = Boolean.parseBoolean(showMessage);
631        if (showErrorMessage) {
632            /* show errprMessage, and remove the layer */
633            Config.getPref().putBoolean("mapdust.showError", false);
634            String errorMessage = "There was a Mapdust service error.";
635            errorMessage += " Please try later.";
636            JOptionPane.showMessageDialog(MainApplication.getMainFrame(), tr(errorMessage));
637        }
638    }
639
640    /**
641     * Returns the <code>MapdustGUI</code> object
642     *
643     * @return the mapdustGUI
644     */
645    public MapdustGUI getMapdustGUI() {
646        return mapdustGUI;
647    }
648
649    /**
650     * Sets the <code>MapdustGUI</code> object.
651     *
652     * @param mapdustGUI the mapdustGUI to set
653     */
654    public void setMapdustGUI(MapdustGUI mapdustGUI) {
655        this.mapdustGUI = mapdustGUI;
656    }
657
658    /**
659     * Returns the <code>MapdustLayer</code> object.
660     *
661     * @return the mapdustLayer
662     */
663    public MapdustLayer getMapdustLayer() {
664        return mapdustLayer;
665    }
666
667    /**
668     * Sets the <code>MapdustLayer</code> object.
669     *
670     * @param mapdustLayer the mapdustLayer to set
671     */
672    public void setMapdustLayer(MapdustLayer mapdustLayer) {
673        this.mapdustLayer = mapdustLayer;
674    }
675
676    /**
677     * Returns the list of <code>MapdustBug</code> objects
678     *
679     * @return the mapdustBugList
680     */
681    public List<MapdustBug> getMapdustBugList() {
682        return mapdustBugList;
683    }
684
685    /**
686     * Returns the MapDust bug filter
687     *
688     * @return the filter
689     */
690    public MapdustBugFilter getFilter() {
691        return filter;
692    }
693
694}
Note: See TracBrowser for help on using the repository browser.