Changeset 12630 in josm


Ignore:
Timestamp:
2017-08-24T00:15:51+02:00 (8 weeks ago)
Author:
Don-vip
Message:

see #15182 - deprecate Main.map and Main.isDisplayingMapView(). Replacements: gui.MainApplication.getMap() / gui.MainApplication.isDisplayingMapView()

Location:
trunk
Files:
157 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/Main.java

    r12629 r12630  
    6060import org.openstreetmap.josm.data.projection.Projection;
    6161import org.openstreetmap.josm.data.projection.ProjectionChangeListener;
     62import org.openstreetmap.josm.gui.MainApplication;
    6263import org.openstreetmap.josm.gui.MainMenu;
    6364import org.openstreetmap.josm.gui.MainPanel;
     
    119120     *
    120121     * @return <code>true</code> if JOSM currently displays a map view
    121      */
     122     * @deprecated use {@link org.openstreetmap.josm.gui.MainApplication#isDisplayingMapView()}
     123     */
     124    @Deprecated
    122125    public static boolean isDisplayingMapView() {
    123126        return map != null && map.mapView != null;
     
    151154     * There should be no need to access this to access any map data. Use {@link #layerManager} instead.
    152155     *
     156     * @deprecated Use {@link org.openstreetmap.josm.gui.MainApplication#getMap()} instead
    153157     * @see MainPanel
    154158     */
     159    @Deprecated
    155160    public static MapFrame map;
    156161
     
    11351140            }
    11361141            if (newValue != null && oldBounds != null) {
    1137                 Main.map.mapView.zoomTo(oldBounds);
     1142                MainApplication.getMap().mapView.zoomTo(oldBounds);
    11381143            }
    11391144            /* TODO - remove layers with fixed projection */
  • trunk/src/org/openstreetmap/josm/actions/AbstractInfoAction.java

    r12620 r12630  
    1919import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2020import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     21import org.openstreetmap.josm.gui.MainApplication;
    2122import org.openstreetmap.josm.gui.help.HelpUtil;
    2223import org.openstreetmap.josm.tools.ImageProvider;
     
    105106        }
    106107
    107         Note noteToShow = Main.isDisplayingMapView() ? Main.map.noteDialog.getSelectedNote() : null;
     108        Note noteToShow = MainApplication.isDisplayingMapView() ? MainApplication.getMap().noteDialog.getSelectedNote() : null;
    108109
    109110        // filter out new primitives which are not yet uploaded to the server
  • trunk/src/org/openstreetmap/josm/actions/AbstractPasteAction.java

    r12560 r12630  
    1111import org.openstreetmap.josm.Main;
    1212import org.openstreetmap.josm.data.coor.EastNorth;
     13import org.openstreetmap.josm.gui.MainApplication;
     14import org.openstreetmap.josm.gui.MapView;
    1315import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
    1416import org.openstreetmap.josm.gui.datatransfer.OsmTransferHandler;
     
    6870    protected EastNorth computePastePosition(ActionEvent e) {
    6971        // default to paste in center of map (pasted via menu or cursor not in MapView)
    70         EastNorth mPosition = Main.map.mapView.getCenter();
     72        MapView mapView = MainApplication.getMap().mapView;
     73        EastNorth mPosition = mapView.getCenter();
    7174        // We previously checked for modifier to know if the action has been trigerred via shortcut or via menu
    7275        // But this does not work if the shortcut is changed to a single key (see #9055)
     
    7477        if (e != null && !getValue(NAME).equals(e.getActionCommand())) {
    7578            final Point mp = MouseInfo.getPointerInfo().getLocation();
    76             final Point tl = Main.map.mapView.getLocationOnScreen();
     79            final Point tl = mapView.getLocationOnScreen();
    7780            final Point pos = new Point(mp.x-tl.x, mp.y-tl.y);
    78             if (Main.map.mapView.contains(pos)) {
    79                 mPosition = Main.map.mapView.getEastNorth(pos.x, pos.y);
     81            if (mapView.contains(pos)) {
     82                mPosition = mapView.getEastNorth(pos.x, pos.y);
    8083            }
    8184        }
  • trunk/src/org/openstreetmap/josm/actions/AddNodeAction.java

    r12104 r12630  
    1414import org.openstreetmap.josm.data.osm.Node;
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
     16import org.openstreetmap.josm.gui.MainApplication;
     17import org.openstreetmap.josm.gui.MapView;
    1618import org.openstreetmap.josm.gui.dialogs.LatLonDialog;
    1719import org.openstreetmap.josm.tools.Shortcut;
     
    6668        Main.main.undoRedo.add(new AddCommand(nnew));
    6769        getLayerManager().getEditDataSet().setSelected(nnew);
    68         if (Main.map.mapView != null && !Main.map.mapView.getRealBounds().contains(nnew.getCoor())) {
     70        MapView mapView = MainApplication.getMap().mapView;
     71        if (mapView != null && !mapView.getRealBounds().contains(nnew.getCoor())) {
    6972            AutoScaleAction.zoomTo(Collections.<OsmPrimitive>singleton(nnew));
    7073        }
  • trunk/src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r12620 r12630  
    2929import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    3030import org.openstreetmap.josm.data.validation.TestError;
     31import org.openstreetmap.josm.gui.MainApplication;
    3132import org.openstreetmap.josm.gui.MapFrame;
    3233import org.openstreetmap.josm.gui.MapFrameListener;
    3334import org.openstreetmap.josm.gui.MapView;
     35import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
    3436import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
    3537import org.openstreetmap.josm.gui.dialogs.ValidatorDialog.ValidatorBoundingXYVisitor;
     
    102104        bboxCalculator.enlargeBoundingBox();
    103105        if (bboxCalculator.getBounds() != null) {
    104             Main.map.mapView.zoomTo(bboxCalculator);
     106            MainApplication.getMap().mapView.zoomTo(bboxCalculator);
    105107        }
    106108    }
     
    191193     */
    192194    public void autoScale() {
    193         if (Main.isDisplayingMapView()) {
     195        if (MainApplication.isDisplayingMapView()) {
     196            MapView mapView = MainApplication.getMap().mapView;
    194197            switch (mode) {
    195198            case "previous":
    196                 Main.map.mapView.zoomPrevious();
     199                mapView.zoomPrevious();
    197200                break;
    198201            case "next":
    199                 Main.map.mapView.zoomNext();
     202                mapView.zoomNext();
    200203                break;
    201204            default:
    202205                BoundingXYVisitor bbox = getBoundingBox();
    203206                if (bbox != null && bbox.getBounds() != null) {
    204                     Main.map.mapView.zoomTo(bbox);
     207                    mapView.zoomTo(bbox);
    205208                }
    206209            }
     
    254257
    255258    private static BoundingXYVisitor modeProblem(ValidatorBoundingXYVisitor v) {
    256         TestError error = Main.map.validatorDialog.getSelectedError();
     259        TestError error = MainApplication.getMap().validatorDialog.getSelectedError();
    257260        if (error == null)
    258261            return null;
     
    288291            }
    289292        } else {
    290             Conflict<? extends OsmPrimitive> c = Main.map.conflictDialog.getSelectedConflict();
     293            ConflictDialog conflictDialog = MainApplication.getMap().conflictDialog;
     294            Conflict<? extends OsmPrimitive> c = conflictDialog.getSelectedConflict();
    291295            if (c != null) {
    292296                sel.add(c.getMy());
    293             } else if (Main.map.conflictDialog.getConflicts() != null) {
    294                 sel = Main.map.conflictDialog.getConflicts().getMyConflictParties();
     297            } else if (conflictDialog.getConflicts() != null) {
     298                sel = conflictDialog.getConflicts().getMyConflictParties();
    295299            }
    296300        }
     
    350354    protected void updateEnabledState() {
    351355        DataSet ds = getLayerManager().getEditDataSet();
     356        MapFrame map = MainApplication.getMap();
    352357        switch (mode) {
    353358        case "selection":
     
    358363            break;
    359364        case "conflict":
    360             setEnabled(Main.map != null && Main.map.conflictDialog.getSelectedConflict() != null);
     365            setEnabled(map != null && map.conflictDialog.getSelectedConflict() != null);
    361366            break;
    362367        case "download":
     
    364369            break;
    365370        case "problem":
    366             setEnabled(Main.map != null && Main.map.validatorDialog.getSelectedError() != null);
     371            setEnabled(map != null && map.validatorDialog.getSelectedError() != null);
    367372            break;
    368373        case "previous":
    369             setEnabled(Main.isDisplayingMapView() && Main.map.mapView.hasZoomUndoEntries());
     374            setEnabled(MainApplication.isDisplayingMapView() && map.mapView.hasZoomUndoEntries());
    370375            break;
    371376        case "next":
    372             setEnabled(Main.isDisplayingMapView() && Main.map.mapView.hasZoomRedoEntries());
     377            setEnabled(MainApplication.isDisplayingMapView() && map.mapView.hasZoomRedoEntries());
    373378            break;
    374379        default:
  • trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java

    r12188 r12630  
    3636import org.openstreetmap.josm.data.osm.RelationMember;
    3737import org.openstreetmap.josm.data.osm.Way;
     38import org.openstreetmap.josm.gui.MainApplication;
    3839import org.openstreetmap.josm.gui.Notification;
    3940import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationMemberTask;
     
    113114                    // uses 'SwingUtilities.invokeLater' to fire events so we have to do the same.)
    114115                    SwingUtilities.invokeLater(() -> {
    115                             Main.map.relationListDialog.selectRelation(relation);
     116                            MainApplication.getMap().relationListDialog.selectRelation(relation);
    116117                            if (Main.pref.getBoolean("multipoly.show-relation-editor", false)) {
    117118                                //Open relation edit window, if set up in preferences
  • trunk/src/org/openstreetmap/josm/actions/DeleteAction.java

    r12504 r12630  
    99import java.util.Collection;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.data.osm.OsmPrimitive;
     12import org.openstreetmap.josm.gui.MainApplication;
     13import org.openstreetmap.josm.gui.MapFrame;
    1314import org.openstreetmap.josm.tools.Shortcut;
    1415
     
    3031    @Override
    3132    public void actionPerformed(ActionEvent e) {
    32         if (!isEnabled() || !Main.map.mapView.isActiveLayerVisible())
     33        MapFrame map = MainApplication.getMap();
     34        if (!isEnabled() || !map.mapView.isActiveLayerVisible())
    3335            return;
    34         Main.map.mapModeDelete.doActionPerformed(e);
     36        map.mapModeDelete.doActionPerformed(e);
    3537    }
    3638
  • trunk/src/org/openstreetmap/josm/actions/DialogsToggleAction.java

    r12132 r12630  
    99
    1010import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
     12import org.openstreetmap.josm.gui.MapFrame;
    1113import org.openstreetmap.josm.tools.ImageProvider;
    1214import org.openstreetmap.josm.tools.Shortcut;
     
    4749
    4850    protected void setMode() {
    49         if (Main.isDisplayingMapView()) {
     51        if (MainApplication.isDisplayingMapView()) {
    5052            boolean selected = isSelected();
    5153            if (!selected) {
     
    5355                sideToolbarPreviouslyVisible = Main.pref.getBoolean("sidetoolbar.visible", true);
    5456            }
    55             Main.map.setDialogsPanelVisible(selected);
    56             Main.map.statusLine.setVisible(selected || Main.pref.getBoolean("statusbar.always-visible", true));
     57            MapFrame map = MainApplication.getMap();
     58            map.setDialogsPanelVisible(selected);
     59            map.statusLine.setVisible(selected || Main.pref.getBoolean("statusbar.always-visible", true));
    5760            Main.main.menu.setVisible(selected || Main.pref.getBoolean("menu.always-visible", true));
    5861            // Toolbars listen to preference changes, use it here
     
    6366                Main.pref.put("sidetoolbar.visible", selected);
    6467            }
    65             Main.map.mapView.rememberLastPositionOnScreen();
     68            map.mapView.rememberLastPositionOnScreen();
    6669        }
    6770    }
  • trunk/src/org/openstreetmap/josm/actions/DownloadAction.java

    r12620 r12630  
    2424import org.openstreetmap.josm.data.ProjectionBounds;
    2525import org.openstreetmap.josm.data.ViewportData;
     26import org.openstreetmap.josm.gui.MainApplication;
     27import org.openstreetmap.josm.gui.MapFrame;
    2628import org.openstreetmap.josm.gui.download.DownloadDialog;
    2729import org.openstreetmap.josm.gui.util.GuiHelper;
     
    125127                }
    126128                // Zoom to the larger download bounds
    127                 if (Main.map != null && bounds != null) {
     129                MapFrame map = MainApplication.getMap();
     130                if (map != null && bounds != null) {
    128131                    final ProjectionBounds pb = bounds;
    129                     GuiHelper.runInEDTAndWait(() -> Main.map.mapView.zoomTo(new ViewportData(pb)));
     132                    GuiHelper.runInEDTAndWait(() -> map.mapView.zoomTo(new ViewportData(pb)));
    130133                }
    131134            });
  • trunk/src/org/openstreetmap/josm/actions/DownloadNotesInViewAction.java

    r11743 r12630  
    1111import org.openstreetmap.josm.actions.downloadtasks.PostDownloadHandler;
    1212import org.openstreetmap.josm.data.Bounds;
     13import org.openstreetmap.josm.gui.MainApplication;
    1314import org.openstreetmap.josm.io.OnlineResource;
    1415
     
    4344    @Override
    4445    public void actionPerformed(ActionEvent e) {
    45         final Bounds bounds = Main.map.mapView.getRealBounds();
     46        final Bounds bounds = MainApplication.getMap().mapView.getRealBounds();
    4647        DownloadNotesTask task = new DownloadNotesTask();
    4748        task.setZoomAfterDownload(false);
  • trunk/src/org/openstreetmap/josm/actions/DownloadOsmInViewAction.java

    r11743 r12630  
    1111import org.openstreetmap.josm.actions.downloadtasks.PostDownloadHandler;
    1212import org.openstreetmap.josm.data.Bounds;
     13import org.openstreetmap.josm.gui.MainApplication;
    1314import org.openstreetmap.josm.io.BoundingBoxDownloader;
    1415import org.openstreetmap.josm.io.OnlineResource;
     
    3132    @Override
    3233    public void actionPerformed(ActionEvent e) {
    33         final Bounds bounds = Main.map.mapView.getRealBounds();
     34        final Bounds bounds = MainApplication.getMap().mapView.getRealBounds();
    3435        DownloadOsmInViewTask task = new DownloadOsmInViewTask();
    3536        task.setZoomAfterDownload(false);
  • trunk/src/org/openstreetmap/josm/actions/FollowLineAction.java

    r12351 r12630  
    1919import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2020import org.openstreetmap.josm.data.osm.Way;
     21import org.openstreetmap.josm.gui.MainApplication;
     22import org.openstreetmap.josm.gui.MapFrame;
    2123import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2224import org.openstreetmap.josm.tools.Shortcut;
     
    6365        if (osmLayer == null)
    6466            return;
    65         if (!(Main.map.mapMode instanceof DrawAction)) return; // We are not on draw mode
     67        MapFrame map = MainApplication.getMap();
     68        if (!(map.mapMode instanceof DrawAction)) return; // We are not on draw mode
    6669
    6770        Collection<Node> selectedPoints = osmLayer.data.getSelectedNodes();
     
    7073            return;
    7174
    72         Node last = ((DrawAction) Main.map.mapMode).getCurrentBaseNode();
     75        Node last = ((DrawAction) map.mapMode).getCurrentBaseNode();
    7376        if (last == null)
    7477            return;
     
    122125            // from aerial imagery or GPS tracks.
    123126            if (DrawAction.VIEWPORT_FOLLOWING.get()) {
    124                 Main.map.mapView.smoothScrollTo(newPoint.getEastNorth());
     127                map.mapView.smoothScrollTo(newPoint.getEastNorth());
    125128            }
    126129        }
  • trunk/src/org/openstreetmap/josm/actions/ImageryAdjustAction.java

    r12620 r12630  
    2929import org.openstreetmap.josm.data.imagery.OffsetBookmark;
    3030import org.openstreetmap.josm.gui.ExtendedDialog;
     31import org.openstreetmap.josm.gui.MainApplication;
     32import org.openstreetmap.josm.gui.MapFrame;
     33import org.openstreetmap.josm.gui.MapView;
    3134import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
    3235import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
     
    7275        EastNorth curOff = old == null ? EastNorth.ZERO : old.getDisplacement(Main.getProjection());
    7376        LatLon center;
    74         if (Main.isDisplayingMapView()) {
    75             center = Main.getProjection().eastNorth2latlon(Main.map.mapView.getCenter());
     77        if (MainApplication.isDisplayingMapView()) {
     78            center = Main.getProjection().eastNorth2latlon(MainApplication.getMap().mapView.getCenter());
    7679        } else {
    7780            center = LatLon.ZERO;
     
    98101
    99102    protected void addListeners() {
    100         Main.map.mapView.addMouseListener(this);
    101         Main.map.mapView.addMouseMotionListener(this);
     103        MapView mapView = MainApplication.getMap().mapView;
     104        mapView.addMouseListener(this);
     105        mapView.addMouseMotionListener(this);
    102106        try {
    103107            Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.KEY_EVENT_MASK);
     
    126130            Logging.error(ex);
    127131        }
    128         if (Main.isDisplayingMapView()) {
    129             Main.map.mapView.removeMouseMotionListener(this);
    130             Main.map.mapView.removeMouseListener(this);
     132        if (MainApplication.isDisplayingMapView()) {
     133            MapFrame map = MainApplication.getMap();
     134            map.mapView.removeMouseMotionListener(this);
     135            map.mapView.removeMouseListener(this);
    131136        }
    132137    }
     
    172177        if (layer.isVisible()) {
    173178            requestFocusInMapView();
    174             prevEastNorth = Main.map.mapView.getEastNorth(e.getX(), e.getY());
    175             Main.map.mapView.setNewCursor(Cursor.MOVE_CURSOR, this);
     179            MapView mapView = MainApplication.getMap().mapView;
     180            prevEastNorth = mapView.getEastNorth(e.getX(), e.getY());
     181            mapView.setNewCursor(Cursor.MOVE_CURSOR, this);
    176182        }
    177183    }
     
    180186    public void mouseDragged(MouseEvent e) {
    181187        if (layer == null || prevEastNorth == null) return;
    182         EastNorth eastNorth = Main.map.mapView.getEastNorth(e.getX(), e.getY());
     188        EastNorth eastNorth = MainApplication.getMap().mapView.getEastNorth(e.getX(), e.getY());
    183189        EastNorth d = tempOffset.getDisplacement().add(eastNorth).subtract(prevEastNorth);
    184190        tempOffset.setDisplacement(d);
     
    192198    @Override
    193199    public void mouseReleased(MouseEvent e) {
    194         Main.map.mapView.repaint();
    195         Main.map.mapView.resetCursor(this);
     200        MapView mapView = MainApplication.getMap().mapView;
     201        mapView.repaint();
     202        mapView.resetCursor(this);
    196203        prevEastNorth = null;
    197204    }
     
    199206    @Override
    200207    public void actionPerformed(ActionEvent e) {
    201         if (offsetDialog != null || layer == null || Main.map == null)
     208        MapFrame map = MainApplication.getMap();
     209        if (offsetDialog != null || layer == null || map == null)
    202210            return;
    203         oldMapMode = Main.map.mapMode;
     211        oldMapMode = map.mapMode;
    204212        super.actionPerformed(e);
    205213    }
     
    266274            }
    267275            updateOffsetIntl();
    268             if (Main.isDisplayingMapView()) {
    269                 Main.map.repaint();
     276            if (MainApplication.isDisplayingMapView()) {
     277                MainApplication.getMap().repaint();
    270278            }
    271279        }
     
    334342
    335343        private void restoreMapModeState() {
    336             if (Main.map == null)
     344            MapFrame map = MainApplication.getMap();
     345            if (map == null)
    337346                return;
    338347            if (oldMapMode != null) {
    339                 Main.map.selectMapMode(oldMapMode);
     348                map.selectMapMode(oldMapMode);
    340349                oldMapMode = null;
    341350            } else {
    342                 Main.map.selectSelectTool(false);
     351                map.selectSelectTool(false);
    343352            }
    344353        }
  • trunk/src/org/openstreetmap/josm/actions/InfoWebAction.java

    r9136 r12630  
    1212import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1313import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     14import org.openstreetmap.josm.gui.MainApplication;
    1415import org.openstreetmap.josm.tools.Shortcut;
    1516
     
    5960    private void updateEnabledStateWithNotes() {
    6061        // Allows enabling if a note is selected, even if no OSM object is selected
    61         if (!isEnabled() && Main.isDisplayingMapView() && Main.map.noteDialog.getSelectedNote() != null) {
     62        if (!isEnabled() && MainApplication.isDisplayingMapView() && MainApplication.getMap().noteDialog.getSelectedNote() != null) {
    6263            setEnabled(true);
    6364        }
  • trunk/src/org/openstreetmap/josm/actions/JoinNodeWayAction.java

    r10716 r12630  
    3030import org.openstreetmap.josm.data.osm.WaySegment;
    3131import org.openstreetmap.josm.data.projection.Projections;
     32import org.openstreetmap.josm.gui.MainApplication;
     33import org.openstreetmap.josm.gui.MapView;
    3234import org.openstreetmap.josm.tools.Geometry;
    3335import org.openstreetmap.josm.tools.MultiMap;
     
    9294
    9395        // Planning phase: decide where we'll insert the nodes and put it all in "data"
     96        MapView mapView = MainApplication.getMap().mapView;
    9497        for (Node node : selectedNodes) {
    95             List<WaySegment> wss = Main.map.mapView.getNearestWaySegments(
    96                     Main.map.mapView.getPoint(node), OsmPrimitive::isSelectable);
    97 
     98            List<WaySegment> wss = mapView.getNearestWaySegments(mapView.getPoint(node), OsmPrimitive::isSelectable);
    9899            MultiMap<Way, Integer> insertPoints = new MultiMap<>();
    99100            for (WaySegment ws : wss) {
  • trunk/src/org/openstreetmap/josm/actions/JumpToAction.java

    r12620 r12630  
    2121import org.openstreetmap.josm.data.coor.LatLon;
    2222import org.openstreetmap.josm.gui.ExtendedDialog;
     23import org.openstreetmap.josm.gui.MainApplication;
    2324import org.openstreetmap.josm.gui.MapView;
    2425import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
     
    9899     */
    99100    public void showJumpToDialog() {
    100         if (!Main.isDisplayingMapView()) {
     101        if (!MainApplication.isDisplayingMapView()) {
    101102            return;
    102103        }
    103         MapView mv = Main.map.mapView;
     104        MapView mv = MainApplication.getMap().mapView;
    104105
    105106        final Optional<Bounds> boundsFromClipboard = Optional
     
    208209    @Override
    209210    protected void updateEnabledState() {
    210         setEnabled(Main.isDisplayingMapView());
     211        setEnabled(MainApplication.isDisplayingMapView());
    211212    }
    212213
  • trunk/src/org/openstreetmap/josm/actions/LassoModeAction.java

    r11713 r12630  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import org.openstreetmap.josm.Main;
    76import org.openstreetmap.josm.actions.mapmode.MapMode;
     7import org.openstreetmap.josm.gui.MainApplication;
     8import org.openstreetmap.josm.gui.MapFrame;
    89import org.openstreetmap.josm.gui.layer.Layer;
    910import org.openstreetmap.josm.tools.ImageProvider;
     
    2728    @Override
    2829    public void enterMode() {
    29         if (Main.isDisplayingMapView()) {
    30             Main.map.mapModeSelect.setLassoMode(true);
    31             Main.map.mapModeSelect.enterMode();
     30        if (MainApplication.isDisplayingMapView()) {
     31            MapFrame map = MainApplication.getMap();
     32            map.mapModeSelect.setLassoMode(true);
     33            map.mapModeSelect.enterMode();
    3234        }
    3335        super.enterMode();
     
    3638    @Override
    3739    public void exitMode() {
    38         if (Main.isDisplayingMapView()) {
    39             Main.map.mapModeSelect.setLassoMode(false);
    40             Main.map.mapModeSelect.exitMode();
     40        if (MainApplication.isDisplayingMapView()) {
     41            MapFrame map = MainApplication.getMap();
     42            map.mapModeSelect.setLassoMode(false);
     43            map.mapModeSelect.exitMode();
    4144        }
    4245        super.exitMode();
     
    4548    @Override
    4649    public boolean layerIsSupported(Layer l) {
    47         return Main.map.mapModeSelect.layerIsSupported(l);
     50        return MainApplication.getMap().mapModeSelect.layerIsSupported(l);
    4851    }
    4952}
  • trunk/src/org/openstreetmap/josm/actions/MergeNodesAction.java

    r12620 r12630  
    3535import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    3636import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     37import org.openstreetmap.josm.gui.MainApplication;
     38import org.openstreetmap.josm.gui.MapView;
    3739import org.openstreetmap.josm.gui.Notification;
    3840import org.openstreetmap.josm.gui.conflict.tags.CombinePrimitiveResolverDialog;
     
    7577
    7678        if (selectedNodes.size() == 1) {
    77             List<Node> nearestNodes = Main.map.mapView.getNearestNodes(
    78                     Main.map.mapView.getPoint(selectedNodes.get(0)), selectedNodes, OsmPrimitive::isUsable);
     79            MapView mapView = MainApplication.getMap().mapView;
     80            List<Node> nearestNodes = mapView.getNearestNodes(
     81                    mapView.getPoint(selectedNodes.get(0)), selectedNodes, OsmPrimitive::isUsable);
    7982            if (nearestNodes.isEmpty()) {
    8083                new Notification(
  • trunk/src/org/openstreetmap/josm/actions/MoveAction.java

    r12316 r12630  
    1919import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2020import org.openstreetmap.josm.data.osm.visitor.AllNodesVisitor;
     21import org.openstreetmap.josm.gui.MainApplication;
     22import org.openstreetmap.josm.gui.MapView;
    2123import org.openstreetmap.josm.tools.Shortcut;
    2224
     
    102104        DataSet ds = getLayerManager().getEditDataSet();
    103105
    104         if (!Main.isDisplayingMapView() || ds == null)
     106        if (!MainApplication.isDisplayingMapView() || ds == null)
    105107            return;
    106108
     
    108110        // achive an 1-pixel movement
    109111
    110         EastNorth en1 = Main.map.mapView.getEastNorth(100, 100);
    111         EastNorth en2 = Main.map.mapView.getEastNorth(101, 101);
     112        MapView mapView = MainApplication.getMap().mapView;
     113        EastNorth en1 = mapView.getEastNorth(100, 100);
     114        EastNorth en2 = mapView.getEastNorth(101, 101);
    112115
    113116        double distx = en2.east() - en1.east();
     
    162165        }
    163166
    164         Main.map.mapView.repaint();
     167        mapView.repaint();
    165168    }
    166169
  • trunk/src/org/openstreetmap/josm/actions/MoveNodeAction.java

    r10552 r12630  
    1313import org.openstreetmap.josm.data.osm.Node;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
     15import org.openstreetmap.josm.gui.MainApplication;
    1516import org.openstreetmap.josm.gui.dialogs.LatLonDialog;
    1617
     
    5051        // move the node
    5152        Main.main.undoRedo.add(new MoveCommand(n, coordinates));
    52         Main.map.mapView.repaint();
     53        MainApplication.getMap().mapView.repaint();
    5354    }
    5455
  • trunk/src/org/openstreetmap/josm/actions/OpenFileAction.java

    r12620 r12630  
    3333import org.openstreetmap.josm.Main;
    3434import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     35import org.openstreetmap.josm.gui.MainApplication;
     36import org.openstreetmap.josm.gui.MapFrame;
    3537import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    3638import org.openstreetmap.josm.gui.widgets.AbstractFileChooser;
     
    178180        @Override
    179181        protected void finish() {
    180             if (Main.map != null) {
    181                 Main.map.repaint();
     182            MapFrame map = MainApplication.getMap();
     183            if (map != null) {
     184                map.repaint();
    182185            }
    183186        }
  • trunk/src/org/openstreetmap/josm/actions/RedoAction.java

    r6380 r12630  
    99
    1010import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
     12import org.openstreetmap.josm.gui.MapFrame;
    1113import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1214import org.openstreetmap.josm.tools.Shortcut;
     
    3133    @Override
    3234    public void actionPerformed(ActionEvent e) {
    33         if (Main.map == null)
     35        MapFrame map = MainApplication.getMap();
     36        if (map == null)
    3437            return;
    35         Main.map.repaint();
     38        map.repaint();
    3639        Main.main.undoRedo.redo();
    3740    }
  • trunk/src/org/openstreetmap/josm/actions/SelectByInternalPointAction.java

    r11247 r12630  
    1717import org.openstreetmap.josm.data.osm.RelationMember;
    1818import org.openstreetmap.josm.data.osm.Way;
     19import org.openstreetmap.josm.data.projection.Projection;
     20import org.openstreetmap.josm.gui.MainApplication;
    1921import org.openstreetmap.josm.tools.Geometry;
    2022
     
    6163            }
    6264        }
     65        Projection projection = MainApplication.getMap().mapView.getProjection();
    6366        for (Relation r : ds.getRelations()) {
    6467            if (r.isUsable() && r.isMultipolygon() && r.isSelectable() && Geometry.isNodeInsideMultiPolygon(n, r, null)) {
     
    7275                // estimate multipolygon size by its bounding box area
    7376                BBox bBox = r.getBBox();
    74                 EastNorth en1 = Main.map.mapView.getProjection().latlon2eastNorth(bBox.getTopLeft());
    75                 EastNorth en2 = Main.map.mapView.getProjection().latlon2eastNorth(bBox.getBottomRight());
     77                EastNorth en1 = projection.latlon2eastNorth(bBox.getTopLeft());
     78                EastNorth en2 = projection.latlon2eastNorth(bBox.getBottomRight());
    7679                double s = Math.abs((en1.east() - en2.east()) * (en1.north() - en2.north()));
    7780                found.put(s <= 0 ? 1e8 : s, r);
  • trunk/src/org/openstreetmap/josm/actions/SessionLoadAction.java

    r12620 r12630  
    2121import org.openstreetmap.josm.Main;
    2222import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     23import org.openstreetmap.josm.gui.MainApplication;
    2324import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2425import org.openstreetmap.josm.gui.layer.Layer;
     
    133134        private void addLayers() {
    134135            if (layers != null && !layers.isEmpty()) {
    135                 boolean noMap = Main.map == null;
     136                boolean noMap = MainApplication.getMap() == null;
    136137                for (Layer l : layers) {
    137138                    if (canceled)
     
    143144                }
    144145                if (noMap && viewport != null) {
    145                     Main.map.mapView.scheduleZoomTo(viewport.getEastNorthViewport(Main.getProjection()));
     146                    MainApplication.getMap().mapView.scheduleZoomTo(viewport.getEastNorthViewport(Main.getProjection()));
    146147                }
    147148            }
  • trunk/src/org/openstreetmap/josm/actions/SessionSaveAsAction.java

    r12620 r12630  
    3535import org.openstreetmap.josm.gui.ExtendedDialog;
    3636import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     37import org.openstreetmap.josm.gui.MainApplication;
    3738import org.openstreetmap.josm.gui.MapFrame;
    3839import org.openstreetmap.josm.gui.MapFrameListener;
     
    283284    @Override
    284285    protected void updateEnabledState() {
    285         setEnabled(Main.isDisplayingMapView());
     286        setEnabled(MainApplication.isDisplayingMapView());
    286287    }
    287288
  • trunk/src/org/openstreetmap/josm/actions/SplitWayAction.java

    r12287 r12630  
    4343import org.openstreetmap.josm.gui.DefaultNameFormatter;
    4444import org.openstreetmap.josm.gui.ExtendedDialog;
     45import org.openstreetmap.josm.gui.MainApplication;
     46import org.openstreetmap.josm.gui.MapFrame;
    4547import org.openstreetmap.josm.gui.Notification;
    4648import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    255257            list.addListSelectionListener(e -> {
    256258                final Way selected = list.getSelectedValue();
    257                 if (selected != null && Main.isDisplayingMapView() && selected.getNodesCount() > 1) {
     259                if (selected != null && MainApplication.isDisplayingMapView() && selected.getNodesCount() > 1) {
    258260                    final Collection<WaySegment> segments = new ArrayList<>(selected.getNodesCount() - 1);
    259261                    final Iterator<Node> it = selected.getNodes().iterator();
     
    272274        protected void setHighlightedWaySegments(Collection<WaySegment> segments) {
    273275            selectedWay.getDataSet().setHighlightedWaySegments(segments);
    274             Main.map.mapView.repaint();
     276            MainApplication.getMap().mapView.repaint();
    275277        }
    276278
     
    542544                Arrays.asList("outer", "inner", "forward", "backward", "north", "south", "east", "west"));
    543545
    544         final boolean isMapModeDraw = Main.map != null && Main.map.mapMode == Main.map.mapModeDraw;
     546        final MapFrame map = MainApplication.getMap();
     547        final boolean isMapModeDraw = map != null && map.mapMode == map.mapModeDraw;
    545548
    546549        // Change the original way
  • trunk/src/org/openstreetmap/josm/actions/UnGlueAction.java

    r12620 r12630  
    3939import org.openstreetmap.josm.gui.DefaultNameFormatter;
    4040import org.openstreetmap.josm.gui.ExtendedDialog;
     41import org.openstreetmap.josm.gui.MainApplication;
    4142import org.openstreetmap.josm.gui.MapView;
    4243import org.openstreetmap.josm.gui.Notification;
     
    308309
    309310        // If this wasn't called from menu, place it where the cursor is/was
     311        MapView mv = MainApplication.getMap().mapView;
    310312        if (e.getSource() instanceof JPanel) {
    311             MapView mv = Main.map.mapView;
    312313            n.setCoor(mv.getLatLon(mv.lastMEvent.getX(), mv.lastMEvent.getY()));
    313314        }
     
    315316        Main.main.undoRedo.add(new SequenceCommand(tr("Unglued Node"), cmds));
    316317        getLayerManager().getEditDataSet().setSelected(n);
    317         Main.map.mapView.repaint();
     318        mv.repaint();
    318319    }
    319320
  • trunk/src/org/openstreetmap/josm/actions/UndoAction.java

    r6380 r12630  
    99
    1010import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
     12import org.openstreetmap.josm.gui.MapFrame;
    1113import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1214import org.openstreetmap.josm.tools.Shortcut;
     
    3133    @Override
    3234    public void actionPerformed(ActionEvent e) {
    33         if (Main.map == null)
     35        MapFrame map = MainApplication.getMap();
     36        if (map == null)
    3437            return;
    35         Main.map.repaint();
     38        map.repaint();
    3639        Main.main.undoRedo.undo();
    3740    }
  • trunk/src/org/openstreetmap/josm/actions/UploadAction.java

    r12537 r12630  
    2222import org.openstreetmap.josm.data.conflict.ConflictCollection;
    2323import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     24import org.openstreetmap.josm.gui.MainApplication;
    2425import org.openstreetmap.josm.gui.io.UploadDialog;
    2526import org.openstreetmap.josm.gui.io.UploadPrimitivesTask;
     
    259260        if (!isEnabled())
    260261            return;
    261         if (Main.map == null) {
     262        if (MainApplication.getMap() == null) {
    262263            JOptionPane.showMessageDialog(
    263264                    Main.parent,
  • trunk/src/org/openstreetmap/josm/actions/ValidateAction.java

    r12211 r12630  
    1818import org.openstreetmap.josm.data.validation.TestError;
    1919import org.openstreetmap.josm.data.validation.util.AggregatePrimitivesVisitor;
     20import org.openstreetmap.josm.gui.MainApplication;
     21import org.openstreetmap.josm.gui.MapFrame;
    2022import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2123import org.openstreetmap.josm.gui.layer.ValidatorLayer;
     
    6264     */
    6365    public void doValidate(boolean getSelectedItems) {
    64         if (Main.map == null || !Main.map.isVisible())
     66        MapFrame map = MainApplication.getMap();
     67        if (map == null || !map.isVisible())
    6568            return;
    6669
     
    140143            //
    141144            GuiHelper.runInEDT(() -> {
    142                 Main.map.validatorDialog.tree.setErrors(errors);
    143                 Main.map.validatorDialog.unfurlDialog();
     145                MapFrame map = MainApplication.getMap();
     146                map.validatorDialog.tree.setErrors(errors);
     147                map.validatorDialog.unfurlDialog();
    144148                //FIXME: nicer way to find / invalidate the corresponding error layer
    145149                Main.getLayerManager().getLayersOfType(ValidatorLayer.class).forEach(ValidatorLayer::invalidate);
  • trunk/src/org/openstreetmap/josm/actions/ZoomInAction.java

    r10318 r12630  
    99
    1010import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
    1112import org.openstreetmap.josm.tools.Shortcut;
    1213
     
    4647    @Override
    4748    public void actionPerformed(ActionEvent e) {
    48         if (!Main.isDisplayingMapView()) return;
    49         Main.map.mapView.zoomIn();
     49        if (!MainApplication.isDisplayingMapView()) return;
     50        MainApplication.getMap().mapView.zoomIn();
    5051    }
    5152
  • trunk/src/org/openstreetmap/josm/actions/ZoomOutAction.java

    r10318 r12630  
    99
    1010import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
    1112import org.openstreetmap.josm.tools.Shortcut;
    1213
     
    3233    @Override
    3334    public void actionPerformed(ActionEvent e) {
    34         if (!Main.isDisplayingMapView()) return;
    35         Main.map.mapView.zoomOut();
     35        if (!MainApplication.isDisplayingMapView()) return;
     36        MainApplication.getMap().mapView.zoomOut();
    3637    }
    3738
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadGpsTask.java

    r11784 r12630  
    1818import org.openstreetmap.josm.data.ViewportData;
    1919import org.openstreetmap.josm.data.gpx.GpxData;
     20import org.openstreetmap.josm.gui.MainApplication;
     21import org.openstreetmap.josm.gui.MapFrame;
    2022import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2123import org.openstreetmap.josm.gui.layer.GpxLayer;
     
    170172                mergeLayer.mergeFrom(layer);
    171173                mergeLayer.invalidate();
    172                 if (Main.map != null && zoomAfterDownload && layer instanceof GpxLayer) {
    173                     Main.map.mapView.scheduleZoomTo(new ViewportData(layer.getViewProjectionBounds()));
     174                MapFrame map = MainApplication.getMap();
     175                if (map != null && zoomAfterDownload && layer instanceof GpxLayer) {
     176                    map.mapView.scheduleZoomTo(new ViewportData(layer.getViewProjectionBounds()));
    174177                }
    175178                return mergeLayer;
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadNotesTask.java

    r12620 r12630  
    1919import org.openstreetmap.josm.data.osm.NoteData;
    2020import org.openstreetmap.josm.data.preferences.IntegerProperty;
     21import org.openstreetmap.josm.gui.MainApplication;
     22import org.openstreetmap.josm.gui.MapFrame;
    2123import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2224import org.openstreetmap.josm.gui.layer.NoteLayer;
     
    132134            if (!noteLayers.isEmpty()) {
    133135                noteLayers.get(0).getNoteData().addNotes(notesData);
    134                 if (Main.map != null && zoomAfterDownload) {
    135                     Main.map.mapView.scheduleZoomTo(new ViewportData(noteLayer.getViewProjectionBounds()));
     136                MapFrame map = MainApplication.getMap();
     137                if (map != null && zoomAfterDownload) {
     138                    map.mapView.scheduleZoomTo(new ViewportData(noteLayer.getViewProjectionBounds()));
    136139                }
    137140            } else {
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmChangeTask.java

    r12620 r12630  
    3232import org.openstreetmap.josm.data.osm.history.HistoryRelation;
    3333import org.openstreetmap.josm.data.osm.history.HistoryWay;
     34import org.openstreetmap.josm.gui.MainApplication;
    3435import org.openstreetmap.josm.gui.history.HistoryLoadTask;
    3536import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     
    195196                // No more primitive to update. Processing is finished
    196197                // Be sure all updated primitives are correctly drawn
    197                 Main.map.repaint();
     198                MainApplication.getMap().repaint();
    198199            } else {
    199200                // Some primitives still need to be loaded
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTask.java

    r12620 r12630  
    2727import org.openstreetmap.josm.data.osm.Way;
    2828import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     29import org.openstreetmap.josm.gui.MainApplication;
     30import org.openstreetmap.josm.gui.MapFrame;
    2931import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    3032import org.openstreetmap.josm.gui.io.UpdatePrimitivesTask;
     
    228230
    229231        protected OsmDataLayer getEditLayer() {
    230             if (!Main.isDisplayingMapView()) return null;
     232            if (!MainApplication.isDisplayingMapView()) return null;
    231233            return Main.getLayerManager().getEditLayer();
    232234        }
     
    280282                Collection<OsmPrimitive> primitivesToUpdate = searchPrimitivesToUpdate(bounds, layer.data);
    281283                layer.mergeFrom(dataSet);
    282                 if (Main.map != null && zoomAfterDownload && bounds != null) {
    283                     Main.map.mapView.zoomTo(new ViewportData(computeBbox(bounds)));
     284                MapFrame map = MainApplication.getMap();
     285                if (map != null && zoomAfterDownload && bounds != null) {
     286                    map.mapView.zoomTo(new ViewportData(computeBbox(bounds)));
    284287                }
    285288                if (!primitivesToUpdate.isEmpty()) {
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadReferrersTask.java

    r10601 r12630  
    2525import org.openstreetmap.josm.data.osm.PrimitiveId;
    2626import org.openstreetmap.josm.data.osm.Way;
     27import org.openstreetmap.josm.gui.MainApplication;
     28import org.openstreetmap.josm.gui.MapFrame;
    2729import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2830import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    131133                JOptionPane.WARNING_MESSAGE
    132134        );
    133         Main.map.conflictDialog.unfurlDialog();
    134         Main.map.repaint();
     135        MapFrame map = MainApplication.getMap();
     136        map.conflictDialog.unfurlDialog();
     137        map.repaint();
    135138    }
    136139
  • trunk/src/org/openstreetmap/josm/actions/mapmode/AddNoteAction.java

    r12620 r12630  
    1313import org.openstreetmap.josm.data.coor.LatLon;
    1414import org.openstreetmap.josm.data.osm.NoteData;
     15import org.openstreetmap.josm.gui.MainApplication;
     16import org.openstreetmap.josm.gui.MapFrame;
    1517import org.openstreetmap.josm.gui.NoteInputDialog;
    1618import org.openstreetmap.josm.gui.Notification;
     
    4850    public void enterMode() {
    4951        super.enterMode();
    50         Main.map.mapView.addMouseListener(this);
    51         Main.map.keyDetector.addKeyListener(this);
     52        MapFrame map = MainApplication.getMap();
     53        map.mapView.addMouseListener(this);
     54        map.keyDetector.addKeyListener(this);
    5255    }
    5356
     
    5558    public void exitMode() {
    5659        super.exitMode();
    57         Main.map.mapView.removeMouseListener(this);
    58         Main.map.keyDetector.removeKeyListener(this);
     60        MapFrame map = MainApplication.getMap();
     61        map.mapView.removeMouseListener(this);
     62        map.keyDetector.removeKeyListener(this);
    5963    }
    6064
     
    6569            return;
    6670        }
    67         Main.map.selectMapMode(Main.map.mapModeSelect);
     71        MapFrame map = MainApplication.getMap();
     72        map.selectMapMode(map.mapModeSelect);
    6873
    6974        NoteInputDialog dialog = new NoteInputDialog(Main.parent, tr("Create new note"), tr("Create note"));
     
    7681        String input = dialog.getInputText();
    7782        if (input != null && !input.isEmpty()) {
    78             LatLon latlon = Main.map.mapView.getLatLon(e.getPoint().x, e.getPoint().y);
     83            LatLon latlon = map.mapView.getLatLon(e.getPoint().x, e.getPoint().y);
    7984            noteData.createNote(latlon, input);
    8085        } else {
     
    8691    public void doKeyPressed(KeyEvent e) {
    8792        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
    88             Main.map.selectMapMode(Main.map.mapModeSelect);
     93            MapFrame map = MainApplication.getMap();
     94            map.selectMapMode(map.mapModeSelect);
    8995        }
    9096    }
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

    r12537 r12630  
    2121import org.openstreetmap.josm.data.osm.Relation;
    2222import org.openstreetmap.josm.data.osm.WaySegment;
     23import org.openstreetmap.josm.gui.MainApplication;
     24import org.openstreetmap.josm.gui.MapFrame;
     25import org.openstreetmap.josm.gui.MapView;
    2326import org.openstreetmap.josm.gui.dialogs.relation.RelationDialogManager;
    2427import org.openstreetmap.josm.gui.layer.Layer;
     
    110113        drawTargetHighlight = Main.pref.getBoolean("draw.target-highlight", true);
    111114
    112         Main.map.mapView.addMouseListener(this);
    113         Main.map.mapView.addMouseMotionListener(this);
     115        MapFrame map = MainApplication.getMap();
     116        map.mapView.addMouseListener(this);
     117        map.mapView.addMouseMotionListener(this);
    114118        // This is required to update the cursors when ctrl/shift/alt is pressed
    115         Main.map.keyDetector.addModifierExListener(this);
     119        map.keyDetector.addModifierExListener(this);
    116120    }
    117121
     
    119123    public void exitMode() {
    120124        super.exitMode();
    121         Main.map.mapView.removeMouseListener(this);
    122         Main.map.mapView.removeMouseMotionListener(this);
    123         Main.map.keyDetector.removeModifierExListener(this);
     125        MapFrame map = MainApplication.getMap();
     126        map.mapView.removeMouseListener(this);
     127        map.mapView.removeMouseMotionListener(this);
     128        map.keyDetector.removeModifierExListener(this);
    124129        removeHighlighting();
    125130    }
     
    245250     */
    246251    private void updateCursor(MouseEvent e, int modifiers) {
    247         if (!Main.isDisplayingMapView())
    248             return;
    249         if (!Main.map.mapView.isActiveLayerVisible() || e == null)
     252        if (!MainApplication.isDisplayingMapView())
     253            return;
     254        MapFrame map = MainApplication.getMap();
     255        if (!map.mapView.isActiveLayerVisible() || e == null)
    250256            return;
    251257
    252258        DeleteParameters parameters = getDeleteParameters(e, modifiers);
    253         Main.map.mapView.setNewCursor(parameters.mode.cursor(), this);
     259        map.mapView.setNewCursor(parameters.mode.cursor(), this);
    254260    }
    255261
     
    288294        if (e.getButton() != MouseEvent.BUTTON1)
    289295            return;
    290         if (!Main.map.mapView.isActiveLayerVisible())
     296        MapFrame map = MainApplication.getMap();
     297        if (!map.mapView.isActiveLayerVisible())
    291298            return;
    292299
    293300        // request focus in order to enable the expected keyboard shortcuts
    294301        //
    295         Main.map.mapView.requestFocus();
     302        map.mapView.requestFocus();
    296303
    297304        Command c = buildDeleteCommands(e, e.getModifiersEx(), false);
     
    318325    @Override
    319326    protected void updateEnabledState() {
    320         setEnabled(Main.isDisplayingMapView() && Main.map.mapView.isActiveLayerDrawable());
     327        setEnabled(MainApplication.isDisplayingMapView() && MainApplication.getMap().mapView.isActiveLayerDrawable());
    321328    }
    322329
     
    363370        DeleteParameters result = new DeleteParameters();
    364371
    365         result.nearestNode = Main.map.mapView.getNearestNode(e.getPoint(), OsmPrimitive::isSelectable);
     372        MapView mapView = MainApplication.getMap().mapView;
     373        result.nearestNode = mapView.getNearestNode(e.getPoint(), OsmPrimitive::isSelectable);
    366374        if (result.nearestNode == null) {
    367             result.nearestSegment = Main.map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
     375            result.nearestSegment = mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
    368376            if (result.nearestSegment != null) {
    369377                if (shift) {
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r12517 r12630  
    5454import org.openstreetmap.josm.data.preferences.DoubleProperty;
    5555import org.openstreetmap.josm.data.preferences.StrokeProperty;
     56import org.openstreetmap.josm.gui.MainApplication;
    5657import org.openstreetmap.josm.gui.MainMenu;
     58import org.openstreetmap.josm.gui.MapFrame;
    5759import org.openstreetmap.josm.gui.MapView;
    5860import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
     
    270272        snapCheckboxMenuItem.getAction().setEnabled(true);
    271273
    272         Main.map.statusLine.getAnglePanel().addMouseListener(snapHelper.anglePopupListener);
     274        MapFrame map = MainApplication.getMap();
     275        map.statusLine.getAnglePanel().addMouseListener(snapHelper.anglePopupListener);
    273276        Main.registerActionShortcut(backspaceAction, backspaceShortcut);
    274277
    275         Main.map.mapView.addMouseListener(this);
    276         Main.map.mapView.addMouseMotionListener(this);
    277         Main.map.mapView.addTemporaryLayer(this);
     278        map.mapView.addMouseListener(this);
     279        map.mapView.addMouseMotionListener(this);
     280        map.mapView.addTemporaryLayer(this);
    278281        SelectionEventManager.getInstance().addSelectionListenerForEdt(this);
    279282
    280         Main.map.keyDetector.addKeyListener(this);
    281         Main.map.keyDetector.addModifierExListener(this);
     283        map.keyDetector.addKeyListener(this);
     284        map.keyDetector.addModifierExListener(this);
    282285        ignoreNextKeyRelease = true;
    283286    }
     
    286289    public void exitMode() {
    287290        super.exitMode();
    288         Main.map.mapView.removeMouseListener(this);
    289         Main.map.mapView.removeMouseMotionListener(this);
    290         Main.map.mapView.removeTemporaryLayer(this);
     291        MapFrame map = MainApplication.getMap();
     292        map.mapView.removeMouseListener(this);
     293        map.mapView.removeMouseMotionListener(this);
     294        map.mapView.removeTemporaryLayer(this);
    291295        SelectionEventManager.getInstance().removeSelectionListener(this);
    292296        Main.unregisterActionShortcut(backspaceAction, backspaceShortcut);
     
    294298        snapCheckboxMenuItem.getAction().setEnabled(false);
    295299
    296         Main.map.statusLine.getAnglePanel().removeMouseListener(snapHelper.anglePopupListener);
    297         Main.map.statusLine.activateAnglePanel(false);
     300        map.statusLine.getAnglePanel().removeMouseListener(snapHelper.anglePopupListener);
     301        map.statusLine.activateAnglePanel(false);
    298302
    299303        removeHighlighting();
    300         Main.map.keyDetector.removeKeyListener(this);
    301         Main.map.keyDetector.removeModifierExListener(this);
     304        map.keyDetector.removeKeyListener(this);
     305        map.keyDetector.removeModifierExListener(this);
    302306    }
    303307
     
    307311    @Override
    308312    public void modifiersExChanged(int modifiers) {
    309         if (!Main.isDisplayingMapView() || !Main.map.mapView.isActiveLayerDrawable())
     313        if (!MainApplication.isDisplayingMapView() || !MainApplication.getMap().mapView.isActiveLayerDrawable())
    310314            return;
    311315        updateKeyModifiersEx(modifiers);
     
    341345    @Override
    342346    public void selectionChanged(SelectionChangeEvent event) {
    343         if (!Main.map.mapView.isActiveLayerDrawable())
     347        if (!MainApplication.getMap().mapView.isActiveLayerDrawable())
    344348            return;
    345349        computeHelperLine();
     
    360364        lastUsedNode = null;
    361365        wayIsFinished = true;
    362         Main.map.selectSelectTool(true);
     366        MainApplication.getMap().selectSelectTool(true);
    363367        snapHelper.noSnapNow();
    364368
     
    392396        if (e.getButton() != MouseEvent.BUTTON1)
    393397            return;
    394         if (!Main.map.mapView.isActiveLayerDrawable())
     398        MapView mapView = MainApplication.getMap().mapView;
     399        if (!mapView.isActiveLayerDrawable())
    395400            return;
    396401        // request focus in order to enable the expected keyboard shortcuts
    397402        //
    398         Main.map.mapView.requestFocus();
     403        mapView.requestFocus();
    399404
    400405        if (e.getClickCount() > 1 && mousePos != null && mousePos.equals(oldMousePos)) {
     
    417422
    418423        boolean newNode = false;
    419         Node n = Main.map.mapView.getNearestNode(mousePos, OsmPrimitive::isSelectable);
     424        Node n = mapView.getNearestNode(mousePos, OsmPrimitive::isSelectable);
    420425        if (ctrl) {
    421426            Iterator<Way> it = ds.getSelectedWays().iterator();
     
    453458                newEN = snapHelper.getSnapPoint(foundPoint);
    454459                // do not add new node if there is some node within snapping distance
    455                 double tolerance = Main.map.mapView.getDist100Pixel() * toleranceMultiplier;
     460                double tolerance = mapView.getDist100Pixel() * toleranceMultiplier;
    456461                if (foundPoint.distance(newEN) > tolerance) {
    457462                    n = new Node(newEN); // point != projected, so we create new node
     
    459464                }
    460465            } else { // n==null, no node found in clicked area
    461                 EastNorth mouseEN = Main.map.mapView.getEastNorth(e.getX(), e.getY());
     466                EastNorth mouseEN = mapView.getEastNorth(e.getX(), e.getY());
    462467                newEN = snapHelper.isSnapOn() ? snapHelper.getSnapPoint(mouseEN) : mouseEN;
    463468                n = new Node(newEN); //create node at clicked point
     
    486491            if (!ctrl) {
    487492                // Insert the node into all the nearby way segments
    488                 List<WaySegment> wss = Main.map.mapView.getNearestWaySegments(
    489                         Main.map.mapView.getPoint(n), OsmPrimitive::isSelectable);
     493                List<WaySegment> wss = mapView.getNearestWaySegments(
     494                        mapView.getPoint(n), OsmPrimitive::isSelectable);
    490495                if (snapHelper.isActive()) {
    491496                    tryToMoveNodeOnIntersection(wss, n);
     
    622627        // from aerial imagery or GPS tracks.
    623628        if (VIEWPORT_FOLLOWING.get()) {
    624             Main.map.mapView.smoothScrollTo(n.getEastNorth());
     629            mapView.smoothScrollTo(n.getEastNorth());
    625630        }
    626631        computeHelperLine();
     
    767772    @Override
    768773    public void mouseMoved(MouseEvent e) {
    769         if (!Main.map.mapView.isActiveLayerDrawable())
     774        if (!MainApplication.getMap().mapView.isActiveLayerDrawable())
    770775            return;
    771776
     
    787792    private void tryToSetBaseSegmentForAngleSnap() {
    788793        if (mousePos != null) {
    789             WaySegment seg = Main.map.mapView.getNearestWaySegment(mousePos, OsmPrimitive::isSelectable);
     794            WaySegment seg = MainApplication.getMap().mapView.getNearestWaySegment(mousePos, OsmPrimitive::isSelectable);
    790795            if (seg != null) {
    791796                snapHelper.setBaseSegment(seg);
     
    809814        Collection<OsmPrimitive> selection = getLayerManager().getEditDataSet().getSelected();
    810815
    811         MapView mv = Main.map.mapView;
     816        MapView mv = MainApplication.getMap().mapView;
    812817        Node currentMouseNode = null;
    813818        mouseOnExistingNode = null;
     
    864869
    865870    static void showStatusInfo(double angle, double hdg, double distance, boolean activeFlag) {
    866         Main.map.statusLine.setAngle(angle);
    867         Main.map.statusLine.activateAnglePanel(activeFlag);
    868         Main.map.statusLine.setHeading(hdg);
    869         Main.map.statusLine.setDist(distance);
     871        MapFrame map = MainApplication.getMap();
     872        map.statusLine.setAngle(angle);
     873        map.statusLine.activateAnglePanel(activeFlag);
     874        map.statusLine.setHeading(hdg);
     875        map.statusLine.setDist(distance);
    870876    }
    871877
     
    10601066        // fall through to default action.
    10611067        // (for semi-parallel lines, intersection might be miles away!)
    1062         if (Main.map.mapView.getPoint2D(n).distance(Main.map.mapView.getPoint2D(intersection)) < SNAP_TO_INTERSECTION_THRESHOLD.get()) {
     1068        MapFrame map = MainApplication.getMap();
     1069        if (map.mapView.getPoint2D(n).distance(map.mapView.getPoint2D(intersection)) < SNAP_TO_INTERSECTION_THRESHOLD.get()) {
    10631070            n.setEastNorth(intersection);
    10641071            return;
     
    11131120    private void addHighlighting() {
    11141121        newHighlights = new HashSet<>();
     1122        MapView mapView = MainApplication.getMap().mapView;
    11151123
    11161124        // if ctrl key is held ("no join"), don't highlight anything
    11171125        if (ctrl) {
    1118             Main.map.mapView.setNewCursor(cursor, this);
     1126            mapView.setNewCursor(cursor, this);
    11191127            redrawIfRequired();
    11201128            return;
     
    11231131        // This happens when nothing is selected, but we still want to highlight the "target node"
    11241132        if (mouseOnExistingNode == null && mousePos != null && getLayerManager().getEditDataSet().selectionEmpty()) {
    1125             mouseOnExistingNode = Main.map.mapView.getNearestNode(mousePos, OsmPrimitive::isSelectable);
     1133            mouseOnExistingNode = mapView.getNearestNode(mousePos, OsmPrimitive::isSelectable);
    11261134        }
    11271135
    11281136        if (mouseOnExistingNode != null) {
    1129             Main.map.mapView.setNewCursor(cursorJoinNode, this);
     1137            mapView.setNewCursor(cursorJoinNode, this);
    11301138            newHighlights.add(mouseOnExistingNode);
    11311139            redrawIfRequired();
     
    11351143        // Insert the node into all the nearby way segments
    11361144        if (mouseOnExistingWays.isEmpty()) {
    1137             Main.map.mapView.setNewCursor(cursor, this);
     1145            mapView.setNewCursor(cursor, this);
    11381146            redrawIfRequired();
    11391147            return;
    11401148        }
    11411149
    1142         Main.map.mapView.setNewCursor(cursorJoinWay, this);
     1150        mapView.setNewCursor(cursorJoinWay, this);
    11431151        newHighlights.addAll(mouseOnExistingWays);
    11441152        redrawIfRequired();
     
    11571165    public void paint(Graphics2D g, MapView mv, Bounds box) {
    11581166        // sanity checks
    1159         if (Main.map.mapView == null || mousePos == null
     1167        MapView mapView = MainApplication.getMap().mapView;
     1168        if (mapView == null || mousePos == null
    11601169                // don't draw line if we don't know where from or where to
    11611170                || currentMouseEastNorth == null || getCurrentBaseNode() == null
    11621171                // don't draw line if mouse is outside window
    1163                 || !Main.map.mapView.getState().getForView(mousePos.getX(), mousePos.getY()).isInView())
     1172                || !mapView.getState().getForView(mousePos.getX(), mousePos.getY()).isInView())
    11641173            return;
    11651174
     
    13681377        @Override
    13691378        protected void updateEnabledState() {
    1370             setEnabled(Main.map != null && Main.map.mapMode instanceof DrawAction);
     1379            MapFrame map = MainApplication.getMap();
     1380            setEnabled(map != null && map.mapMode instanceof DrawAction);
    13711381        }
    13721382    }
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawSnapHelper.java

    r12620 r12630  
    2525import org.openstreetmap.josm.data.osm.Way;
    2626import org.openstreetmap.josm.data.osm.WaySegment;
     27import org.openstreetmap.josm.gui.MainApplication;
     28import org.openstreetmap.josm.gui.MapView;
    2729import org.openstreetmap.josm.gui.MapViewState;
    2830import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
     
    335337     */
    336338    public void checkAngleSnapping(EastNorth currentEN, double baseHeading, double curHeading) {
     339        MapView mapView = MainApplication.getMap().mapView;
    337340        EastNorth p0 = drawAction.getCurrentBaseNode().getEastNorth();
    338341        EastNorth snapPoint = currentEN;
     
    375378                pe = Math.sin(phi);
    376379                pn = Math.cos(phi);
    377                 double scale = 20 * Main.map.mapView.getDist100Pixel();
     380                double scale = 20 * mapView.getDist100Pixel();
    378381                dir2 = new EastNorth(e0 + scale * pe, n0 + scale * pn);
    379382                snapPoint = getSnapPoint(currentEN);
     
    384387
    385388        // find out the distance, in metres, between the base point and projected point
    386         LatLon mouseLatLon = Main.map.mapView.getProjection().eastNorth2latlon(snapPoint);
     389        LatLon mouseLatLon = mapView.getProjection().eastNorth2latlon(snapPoint);
    387390        double distance = this.drawAction.getCurrentBaseNode().getCoor().greatCircleDistance(mouseLatLon);
    388391        double hdg = Utils.toDegrees(p0.heading(snapPoint));
     
    436439        double dn = p.north()-n0;
    437440        double l = de*pe+dn*pn;
    438         double delta = Main.map.mapView.getDist100Pixel()/20;
     441        double delta = MainApplication.getMap().mapView.getDist100Pixel()/20;
    439442        if (!absoluteFix && l < delta) {
    440443            active = false;
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

    r12620 r12630  
    4545import org.openstreetmap.josm.data.osm.WaySegment;
    4646import org.openstreetmap.josm.data.preferences.ColorProperty;
     47import org.openstreetmap.josm.gui.MainApplication;
    4748import org.openstreetmap.josm.gui.MainMenu;
     49import org.openstreetmap.josm.gui.MapFrame;
    4850import org.openstreetmap.josm.gui.MapView;
    4951import org.openstreetmap.josm.gui.draw.MapViewPath;
     
    205207        @Override
    206208        protected void updateEnabledState() {
    207             setEnabled(Main.map != null && Main.map.mapMode instanceof ExtrudeAction);
     209            MapFrame map = MainApplication.getMap();
     210            setEnabled(map != null && map.mapMode instanceof ExtrudeAction);
    208211        }
    209212    }
     
    293296    public void enterMode() {
    294297        super.enterMode();
    295         Main.map.mapView.addMouseListener(this);
    296         Main.map.mapView.addMouseMotionListener(this);
     298        MapFrame map = MainApplication.getMap();
     299        map.mapView.addMouseListener(this);
     300        map.mapView.addMouseMotionListener(this);
    297301        ignoreNextKeyRelease = true;
    298         Main.map.keyDetector.addKeyListener(this);
    299         Main.map.keyDetector.addModifierExListener(this);
     302        map.keyDetector.addKeyListener(this);
     303        map.keyDetector.addModifierExListener(this);
    300304    }
    301305
     
    321325    @Override
    322326    public void exitMode() {
    323         Main.map.mapView.removeMouseListener(this);
    324         Main.map.mapView.removeMouseMotionListener(this);
    325         Main.map.mapView.removeTemporaryLayer(this);
     327        MapFrame map = MainApplication.getMap();
     328        map.mapView.removeMouseListener(this);
     329        map.mapView.removeMouseMotionListener(this);
     330        map.mapView.removeTemporaryLayer(this);
    326331        dualAlignCheckboxMenuItem.getAction().setEnabled(false);
    327         Main.map.keyDetector.removeKeyListener(this);
    328         Main.map.keyDetector.removeModifierExListener(this);
     332        map.keyDetector.removeKeyListener(this);
     333        map.keyDetector.removeModifierExListener(this);
    329334        super.exitMode();
    330335    }
     
    339344    @Override
    340345    public void modifiersExChanged(int modifiers) {
    341         if (!Main.isDisplayingMapView() || !Main.map.mapView.isActiveLayerDrawable())
     346        MapFrame map = MainApplication.getMap();
     347        if (!MainApplication.isDisplayingMapView() || !map.mapView.isActiveLayerDrawable())
    342348            return;
    343349        updateKeyModifiersEx(modifiers);
    344350        if (mode == Mode.select) {
    345             Main.map.mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
     351            map.mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
    346352        }
    347353    }
     
    380386    @Override
    381387    public void mousePressed(MouseEvent e) {
    382         if (!Main.map.mapView.isActiveLayerVisible())
     388        MapFrame map = MainApplication.getMap();
     389        if (!map.mapView.isActiveLayerVisible())
    383390            return;
    384391        if (!(Boolean) this.getValue("active"))
     
    390397        updateKeyModifiers(e);
    391398
    392         selectedNode = Main.map.mapView.getNearestNode(e.getPoint(), OsmPrimitive::isSelectable);
    393         selectedSegment = Main.map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
     399        selectedNode = map.mapView.getNearestNode(e.getPoint(), OsmPrimitive::isSelectable);
     400        selectedSegment = map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
    394401
    395402        // If nothing gets caught, stay in select mode
     
    441448        moveCommand2 = null;
    442449
    443         Main.map.mapView.addTemporaryLayer(this);
     450        map.mapView.addTemporaryLayer(this);
    444451
    445452        updateStatusLine();
    446         Main.map.mapView.repaint();
     453        map.mapView.repaint();
    447454
    448455        // Make note of time pressed
     
    459466    @Override
    460467    public void mouseDragged(MouseEvent e) {
    461         if (!Main.map.mapView.isActiveLayerVisible())
     468        MapView mapView = MainApplication.getMap().mapView;
     469        if (!mapView.isActiveLayerVisible())
    462470            return;
    463471
     
    471479            //move, create new and extrude mode - move the selected segment
    472480
    473             EastNorth mouseEn = Main.map.mapView.getEastNorth(e.getPoint().x, e.getPoint().y);
     481            EastNorth mouseEn = mapView.getEastNorth(e.getPoint().x, e.getPoint().y);
    474482            EastNorth bestMovement = calculateBestMovementAndNewNodes(mouseEn);
    475483
    476             Main.map.mapView.setNewCursor(Cursor.MOVE_CURSOR, this);
     484            mapView.setNewCursor(Cursor.MOVE_CURSOR, this);
    477485
    478486            if (dualAlignActive) {
     
    511519            }
    512520
    513             Main.map.mapView.repaint();
     521            mapView.repaint();
    514522        }
    515523    }
     
    522530    public void mouseReleased(MouseEvent e) {
    523531
    524         if (!Main.map.mapView.isActiveLayerVisible())
     532        MapView mapView = MainApplication.getMap().mapView;
     533        if (!mapView.isActiveLayerVisible())
    525534            return;
    526535
     
    553562            updateKeyModifiers(e);
    554563            // Switch back into select mode
    555             Main.map.mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
    556             Main.map.mapView.removeTemporaryLayer(this);
     564            mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
     565            mapView.removeTemporaryLayer(this);
    557566            selectedSegment = null;
    558567            moveCommand = null;
     
    560569            dualAlignSegmentCollapsed = false;
    561570            updateStatusLine();
    562             Main.map.mapView.repaint();
     571            mapView.repaint();
    563572        }
    564573    }
     
    574583    private static void addNewNode(MouseEvent e) {
    575584        // Should maybe do the same as in DrawAction and fetch all nearby segments?
    576         WaySegment ws = Main.map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
     585        MapView mapView = MainApplication.getMap().mapView;
     586        WaySegment ws = mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
    577587        if (ws != null) {
    578             Node n = new Node(Main.map.mapView.getLatLon(e.getX(), e.getY()));
     588            Node n = new Node(mapView.getLatLon(e.getX(), e.getY()));
    579589            EastNorth a = ws.getFirstNode().getEastNorth();
    580590            EastNorth b = ws.getSecondNode().getEastNorth();
     
    743753    private EastNorth calculateBestMovement(EastNorth mouseEn) {
    744754
    745         EastNorth initialMouseEn = Main.map.mapView.getEastNorth(initialMousePos.x, initialMousePos.y);
     755        EastNorth initialMouseEn = MainApplication.getMap().mapView.getEastNorth(initialMousePos.x, initialMousePos.y);
    746756        EastNorth mouseMovement = mouseEn.subtract(initialMouseEn);
    747757
     
    926936        double distance = Main.getProjection().eastNorth2latlon(initialN1en).greatCircleDistance(
    927937                Main.getProjection().eastNorth2latlon(n1movedEn));
    928         Main.map.statusLine.setDist(distance);
     938        MainApplication.getMap().statusLine.setDist(distance);
    929939        updateStatusLine();
    930940
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ImproveWayAccuracyAction.java

    r12581 r12630  
    4040import org.openstreetmap.josm.data.preferences.IntegerProperty;
    4141import org.openstreetmap.josm.data.preferences.StrokeProperty;
     42import org.openstreetmap.josm.gui.MainApplication;
     43import org.openstreetmap.josm.gui.MapFrame;
    4244import org.openstreetmap.josm.gui.MapView;
    4345import org.openstreetmap.josm.gui.draw.MapViewPath;
     
    138140        readPreferences();
    139141
    140         mv = Main.map.mapView;
     142        MapFrame map = MainApplication.getMap();
     143        mv = map.mapView;
    141144        mousePos = null;
    142145        oldModeHelpText = "";
     
    148151        updateStateByCurrentSelection();
    149152
    150         Main.map.mapView.addMouseListener(this);
    151         Main.map.mapView.addMouseMotionListener(this);
    152         Main.map.mapView.addTemporaryLayer(temporaryLayer);
     153        map.mapView.addMouseListener(this);
     154        map.mapView.addMouseMotionListener(this);
     155        map.mapView.addTemporaryLayer(temporaryLayer);
    153156        DataSet.addSelectionListener(this);
    154157
    155         Main.map.keyDetector.addModifierExListener(this);
     158        map.keyDetector.addModifierExListener(this);
    156159    }
    157160
     
    165168        super.exitMode();
    166169
    167         Main.map.mapView.removeMouseListener(this);
    168         Main.map.mapView.removeMouseMotionListener(this);
    169         Main.map.mapView.removeTemporaryLayer(temporaryLayer);
     170        MapFrame map = MainApplication.getMap();
     171        map.mapView.removeMouseListener(this);
     172        map.mapView.removeMouseMotionListener(this);
     173        map.mapView.removeTemporaryLayer(temporaryLayer);
    170174        DataSet.removeSelectionListener(this);
    171175
    172         Main.map.keyDetector.removeModifierExListener(this);
     176        map.keyDetector.removeModifierExListener(this);
    173177        temporaryLayer.invalidate();
    174178    }
     
    179183        if (!newModeHelpText.equals(oldModeHelpText)) {
    180184            oldModeHelpText = newModeHelpText;
    181             Main.map.statusLine.setHelpText(newModeHelpText);
    182             Main.map.statusLine.repaint();
     185            MapFrame map = MainApplication.getMap();
     186            map.statusLine.setHelpText(newModeHelpText);
     187            map.statusLine.repaint();
    183188        }
    184189    }
     
    348353    @Override
    349354    public void modifiersExChanged(int modifiers) {
    350         if (!Main.isDisplayingMapView() || !Main.map.mapView.isActiveLayerDrawable()) {
     355        if (!MainApplication.isDisplayingMapView() || !MainApplication.getMap().mapView.isActiveLayerDrawable()) {
    351356            return;
    352357        }
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ImproveWayAccuracyHelper.java

    r10716 r12630  
    66import java.util.List;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.data.coor.EastNorth;
    109import org.openstreetmap.josm.data.osm.Node;
     
    1211import org.openstreetmap.josm.data.osm.Way;
    1312import org.openstreetmap.josm.data.osm.WaySegment;
     13import org.openstreetmap.josm.gui.MainApplication;
    1414import org.openstreetmap.josm.gui.MapView;
    1515import org.openstreetmap.josm.tools.Geometry;
     
    5757        }
    5858
    59         return Main.map.mapView.getNearestWay(p, OsmPrimitive::isSelectable);
     59        return MainApplication.getMap().mapView.getNearestWay(p, OsmPrimitive::isSelectable);
    6060    }
    6161
  • trunk/src/org/openstreetmap/josm/actions/mapmode/MapMode.java

    r12526 r12630  
    1616import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    1717import org.openstreetmap.josm.data.osm.OsmPrimitive;
     18import org.openstreetmap.josm.gui.MainApplication;
    1819import org.openstreetmap.josm.gui.MapFrame;
    1920import org.openstreetmap.josm.gui.layer.Layer;
     
    99100        Main.pref.addPreferenceChangeListener(this);
    100101        readPreferences();
    101         Main.map.mapView.setNewCursor(cursor, this);
     102        MainApplication.getMap().mapView.setNewCursor(cursor, this);
    102103        updateStatusLine();
    103104    }
     
    109110        putValue("active", Boolean.FALSE);
    110111        Main.pref.removePreferenceChangeListener(this);
    111         Main.map.mapView.resetCursor(this);
     112        MainApplication.getMap().mapView.resetCursor(this);
    112113    }
    113114
    114115    protected void updateStatusLine() {
    115         if (Main.map != null && Main.map.statusLine != null) {
    116             Main.map.statusLine.setHelpText(getModeHelpText());
    117             Main.map.statusLine.repaint();
     116        MapFrame map = MainApplication.getMap();
     117        if (map != null && map.statusLine != null) {
     118            map.statusLine.setHelpText(getModeHelpText());
     119            map.statusLine.repaint();
    118120        }
    119121    }
     
    134136    @Override
    135137    public void actionPerformed(ActionEvent e) {
    136         if (Main.isDisplayingMapView()) {
    137             Main.map.selectMapMode(this);
     138        if (MainApplication.isDisplayingMapView()) {
     139            MainApplication.getMap().selectMapMode(this);
    138140        }
    139141    }
     
    225227        if (isEnabled()) {
    226228            // request focus in order to enable the expected keyboard shortcuts (see #8710)
    227             Main.map.mapView.requestFocus();
     229            MainApplication.getMap().mapView.requestFocus();
    228230        }
    229231    }
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ParallelWayAction.java

    r12620 r12630  
    2525import javax.swing.JOptionPane;
    2626
    27 import org.openstreetmap.josm.Main;
    2827import org.openstreetmap.josm.data.Bounds;
    2928import org.openstreetmap.josm.data.SystemOfMeasurement;
     
    4039import org.openstreetmap.josm.data.preferences.IntegerProperty;
    4140import org.openstreetmap.josm.data.preferences.StrokeProperty;
     41import org.openstreetmap.josm.gui.MainApplication;
    4242import org.openstreetmap.josm.gui.MapFrame;
    4343import org.openstreetmap.josm.gui.MapView;
     
    172172        mv.addTemporaryLayer(temporaryLayer);
    173173
    174         //// Needed to update the mouse cursor if modifiers are changed when the mouse is motionless
    175         Main.map.keyDetector.addModifierExListener(this);
     174        // Needed to update the mouse cursor if modifiers are changed when the mouse is motionless
     175        MainApplication.getMap().keyDetector.addModifierExListener(this);
    176176        sourceWays = new LinkedHashSet<>(getLayerManager().getEditDataSet().getSelectedWays());
    177177        for (Way w : sourceWays) {
     
    186186        mv.removeMouseMotionListener(this);
    187187        mv.removeTemporaryLayer(temporaryLayer);
    188         Main.map.statusLine.setDist(-1);
    189         Main.map.statusLine.repaint();
    190         Main.map.keyDetector.removeModifierExListener(this);
     188        MapFrame map = MainApplication.getMap();
     189        map.statusLine.setDist(-1);
     190        map.statusLine.repaint();
     191        map.keyDetector.removeModifierExListener(this);
    191192        removeWayHighlighting(sourceWays);
    192193        pWays = null;
     
    217218    @Override
    218219    public void modifiersExChanged(int modifiers) {
    219         if (Main.map == null || mv == null || !mv.isActiveLayerDrawable())
     220        if (MainApplication.getMap() == null || mv == null || !mv.isActiveLayerDrawable())
    220221            return;
    221222
     
    431432        pWays.changeOffset(d);
    432433
    433         Main.map.statusLine.setDist(Math.abs(snappedRealD));
    434         Main.map.statusLine.repaint();
     434        MapFrame map = MainApplication.getMap();
     435        map.statusLine.setDist(Math.abs(snappedRealD));
     436        map.statusLine.repaint();
    435437        temporaryLayer.invalidate();
    436438    }
  • trunk/src/org/openstreetmap/josm/actions/mapmode/PlayHeadDragMode.java

    r11713 r12630  
    88import java.awt.event.MouseEvent;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.coor.EastNorth;
     11import org.openstreetmap.josm.gui.MainApplication;
     12import org.openstreetmap.josm.gui.MapFrame;
    1213import org.openstreetmap.josm.gui.layer.markerlayer.PlayHeadMarker;
    1314import org.openstreetmap.josm.tools.Shortcut;
     
    3839    @Override public void enterMode() {
    3940        super.enterMode();
    40         Main.map.mapView.addMouseListener(this);
    41         Main.map.mapView.addMouseMotionListener(this);
     41        MapFrame map = MainApplication.getMap();
     42        map.mapView.addMouseListener(this);
     43        map.mapView.addMouseMotionListener(this);
    4244    }
    4345
    4446    @Override public void exitMode() {
    4547        super.exitMode();
    46         Main.map.mapView.removeMouseListener(this);
    47         Main.map.mapView.removeMouseMotionListener(this);
     48        MapFrame map = MainApplication.getMap();
     49        map.mapView.removeMouseListener(this);
     50        map.mapView.removeMouseMotionListener(this);
    4851    }
    4952
     
    6265        }
    6366        if (p.distance(mousePos) == 0) return;
    64         playHeadMarker.drag(Main.map.mapView.getEastNorth(ev.getX(), ev.getY()));
     67        playHeadMarker.drag(MainApplication.getMap().mapView.getEastNorth(ev.getX(), ev.getY()));
    6568        mousePos = p;
    6669    }
     
    7477        updateKeyModifiers(ev);
    7578
    76         EastNorth en = Main.map.mapView.getEastNorth(ev.getX(), ev.getY());
     79        EastNorth en = MainApplication.getMap().mapView.getEastNorth(ev.getX(), ev.getY());
    7780        if (!shift) {
    7881            playHeadMarker.reposition(en);
  • trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

    r12620 r12630  
    4040import org.openstreetmap.josm.data.osm.visitor.paint.WireframeMapRenderer;
    4141import org.openstreetmap.josm.gui.ExtendedDialog;
     42import org.openstreetmap.josm.gui.MainApplication;
    4243import org.openstreetmap.josm.gui.MapFrame;
    4344import org.openstreetmap.josm.gui.MapView;
     
    209210        virtualManager.init();
    210211        // This is required to update the cursors when ctrl/shift/alt is pressed
    211         Main.map.keyDetector.addModifierExListener(this);
    212         Main.map.keyDetector.addKeyListener(this);
     212        MapFrame map = MainApplication.getMap();
     213        map.keyDetector.addModifierExListener(this);
     214        map.keyDetector.addKeyListener(this);
    213215    }
    214216
     
    220222        mv.removeMouseMotionListener(this);
    221223        mv.setVirtualNodesEnabled(false);
    222         Main.map.keyDetector.removeModifierExListener(this);
    223         Main.map.keyDetector.removeKeyListener(this);
     224        MapFrame map = MainApplication.getMap();
     225        map.keyDetector.removeModifierExListener(this);
     226        map.keyDetector.removeKeyListener(this);
    224227        removeHighlighting();
    225228    }
     
    227230    @Override
    228231    public void modifiersExChanged(int modifiers) {
    229         if (!Main.isDisplayingMapView() || oldEvent == null) return;
     232        if (!MainApplication.isDisplayingMapView() || oldEvent == null) return;
    230233        if (giveUserFeedback(oldEvent, modifiers)) {
    231234            mv.repaint();
     
    568571        startingDraggingPos = null;
    569572        mouseReleaseTime = System.currentTimeMillis();
     573        MapFrame map = MainApplication.getMap();
    570574
    571575        if (mode == Mode.SELECT) {
     
    578582            // Select Draw Tool if no selection has been made
    579583            if (!cancelDrawMode && getLayerManager().getEditDataSet().selectionEmpty()) {
    580                 Main.map.selectDrawTool(true);
     584                map.selectDrawTool(true);
    581585                updateStatusLine();
    582586                return;
     
    599603                        // We need to do it like this as otherwise drawAction will see a double
    600604                        // click and switch back to SelectMode
    601                         Main.worker.execute(() -> Main.map.selectDrawTool(true));
     605                        Main.worker.execute(() -> map.selectDrawTool(true));
    602606                        return;
    603607                    }
     
    630634    @Override
    631635    public void doKeyPressed(KeyEvent e) {
    632         if (!repeatedKeySwitchLassoOption || !Main.isDisplayingMapView() || !getShortcut().isEvent(e))
     636        if (!repeatedKeySwitchLassoOption || !MainApplication.isDisplayingMapView() || !getShortcut().isEvent(e))
    633637            return;
    634638        if (Logging.isDebugEnabled()) {
     
    636640        }
    637641        e.consume();
     642        MapFrame map = MainApplication.getMap();
    638643        if (!lassoMode) {
    639             Main.map.selectMapMode(Main.map.mapModeSelectLasso);
     644            map.selectMapMode(map.mapModeSelectLasso);
    640645        } else {
    641             Main.map.selectMapMode(Main.map.mapModeSelect);
     646            map.selectMapMode(map.mapModeSelect);
    642647        }
    643648    }
     
    751756                Collection<Way> ways = ds.getSelectedWays();
    752757                if (doesImpactStatusLine(affectedNodes, ways)) {
    753                     Main.map.statusLine.setDist(ways);
     758                    MainApplication.getMap().statusLine.setDist(ways);
    754759                }
    755760            } finally {
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ZoomAction.java

    r11713 r12630  
    88import java.awt.event.MouseEvent;
    99
    10 import org.openstreetmap.josm.Main;
     10import org.openstreetmap.josm.gui.MainApplication;
    1111import org.openstreetmap.josm.gui.MapFrame;
    1212import org.openstreetmap.josm.gui.MapView;
     
    5353    @Override
    5454    public void selectionEnded(Rectangle r, MouseEvent e) {
    55         if (r.width >= 3 && r.height >= 3 && Main.isDisplayingMapView()) {
    56             MapView mv = Main.map.mapView;
     55        if (r.width >= 3 && r.height >= 3 && MainApplication.isDisplayingMapView()) {
     56            MapView mv = MainApplication.getMap().mapView;
    5757            mv.zoomToFactor(mv.getEastNorth(r.x+r.width/2, r.y+r.height/2), r.getWidth()/mv.getWidth());
    5858        }
     
    6161    @Override public void enterMode() {
    6262        super.enterMode();
    63         selectionManager.register(Main.map.mapView, false);
     63        selectionManager.register(MainApplication.getMap().mapView, false);
    6464    }
    6565
    6666    @Override public void exitMode() {
    6767        super.exitMode();
    68         selectionManager.unregister(Main.map.mapView);
     68        selectionManager.unregister(MainApplication.getMap().mapView);
    6969    }
    7070
  • trunk/src/org/openstreetmap/josm/actions/relation/DeleteRelationsAction.java

    r10453 r12630  
    1010import org.openstreetmap.josm.actions.mapmode.DeleteAction;
    1111import org.openstreetmap.josm.data.osm.Relation;
     12import org.openstreetmap.josm.gui.MainApplication;
     13import org.openstreetmap.josm.gui.MapFrame;
    1214import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1315import org.openstreetmap.josm.tools.ImageProvider;
     
    3537        DeleteAction.deleteRelations(layer, toDelete);
    3638        // clear selection after deletion
    37         if (Main.map.relationListDialog != null)
    38                 Main.map.relationListDialog.selectRelations(null);
     39        MapFrame map = MainApplication.getMap();
     40        if (map.relationListDialog != null)
     41            map.relationListDialog.selectRelations(null);
    3942    }
    4043
  • trunk/src/org/openstreetmap/josm/actions/relation/DownloadMembersAction.java

    r10657 r12630  
    1010import org.openstreetmap.josm.Main;
    1111import org.openstreetmap.josm.data.osm.OsmPrimitive;
     12import org.openstreetmap.josm.gui.MainApplication;
    1213import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationTask;
    1314import org.openstreetmap.josm.io.OnlineResource;
     
    3334    @Override
    3435    public void actionPerformed(ActionEvent e) {
    35         if (!isEnabled() || relations.isEmpty() || !Main.isDisplayingMapView()) return;
     36        if (!isEnabled() || relations.isEmpty() || !MainApplication.isDisplayingMapView()) return;
    3637        Main.worker.submit(new DownloadRelationTask(relations, Main.getLayerManager().getEditLayer()));
    3738    }
  • trunk/src/org/openstreetmap/josm/actions/relation/DownloadSelectedIncompleteMembersAction.java

    r10717 r12630  
    1212import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1313import org.openstreetmap.josm.data.osm.Relation;
     14import org.openstreetmap.josm.gui.MainApplication;
    1415import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationMemberTask;
    1516import org.openstreetmap.josm.io.OnlineResource;
     
    4950    @Override
    5051    public void actionPerformed(ActionEvent e) {
    51         if (!isEnabled() || relations.isEmpty() || !Main.isDisplayingMapView()) return;
     52        if (!isEnabled() || relations.isEmpty() || !MainApplication.isDisplayingMapView()) return;
    5253        Main.worker.submit(new DownloadRelationMemberTask(
    5354                relations,
  • trunk/src/org/openstreetmap/josm/actions/relation/EditRelationAction.java

    r10428 r12630  
    1616import org.openstreetmap.josm.data.osm.Relation;
    1717import org.openstreetmap.josm.data.osm.RelationMember;
     18import org.openstreetmap.josm.gui.MainApplication;
    1819import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
    1920import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    4243    public static Set<RelationMember> getMembersForCurrentSelection(Relation r) {
    4344        Set<RelationMember> members = new HashSet<>();
    44         if (Main.isDisplayingMapView()) {
     45        if (MainApplication.isDisplayingMapView()) {
    4546            OsmDataLayer editLayer = Main.getLayerManager().getEditLayer();
    4647            if (editLayer != null && editLayer.data != null) {
     
    6162     */
    6263    public static void launchEditor(Relation toEdit) {
    63         if (toEdit == null || toEdit.isDeleted() || !Main.isDisplayingMapView()) return;
     64        if (toEdit == null || toEdit.isDeleted() || !MainApplication.isDisplayingMapView()) return;
    6465        RelationEditor.getEditor(Main.getLayerManager().getEditLayer(), toEdit,
    6566                getMembersForCurrentSelection(toEdit)).setVisible(true);
  • trunk/src/org/openstreetmap/josm/actions/relation/RecentRelationsAction.java

    r11869 r12630  
    2222import org.openstreetmap.josm.data.osm.Relation;
    2323import org.openstreetmap.josm.gui.DefaultNameFormatter;
     24import org.openstreetmap.josm.gui.MainApplication;
    2425import org.openstreetmap.josm.gui.SideButton;
    2526import org.openstreetmap.josm.gui.layer.Layer;
     
    123124     */
    124125    public static List<Relation> getRecentRelationsOnActiveLayer() {
    125         if (!Main.isDisplayingMapView())
     126        if (!MainApplication.isDisplayingMapView())
    126127            return Collections.emptyList();
    127128        Layer activeLayer = Main.getLayerManager().getActiveLayer();
  • trunk/src/org/openstreetmap/josm/actions/relation/SelectInRelationListAction.java

    r8510 r12630  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
     8import org.openstreetmap.josm.gui.MainApplication;
     9import org.openstreetmap.josm.gui.MapFrame;
    910import org.openstreetmap.josm.tools.ImageProvider;
    1011
     
    2627    @Override
    2728    public void actionPerformed(ActionEvent e) {
    28         if (!isEnabled() || relations.isEmpty() || Main.map == null || Main.map.relationListDialog == null) return;
    29         Main.map.relationListDialog.unfurlDialog();
    30         Main.map.relationListDialog.selectRelations(relations);
     29        MapFrame map = MainApplication.getMap();
     30        if (!isEnabled() || relations.isEmpty() || map == null || map.relationListDialog == null) return;
     31        map.relationListDialog.unfurlDialog();
     32        map.relationListDialog.selectRelations(relations);
    3133    }
    3234}
  • trunk/src/org/openstreetmap/josm/actions/relation/SelectMembersAction.java

    r11038 r12630  
    1111import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1212import org.openstreetmap.josm.data.osm.Relation;
     13import org.openstreetmap.josm.gui.MainApplication;
    1314import org.openstreetmap.josm.tools.ImageProvider;
    1415
     
    3637    @Override
    3738    public void actionPerformed(ActionEvent e) {
    38         if (!isEnabled() || relations.isEmpty() || !Main.isDisplayingMapView()) return;
     39        if (!isEnabled() || relations.isEmpty() || !MainApplication.isDisplayingMapView()) return;
    3940
    4041        Set<OsmPrimitive> members = new HashSet<>();
  • trunk/src/org/openstreetmap/josm/actions/search/SearchAction.java

    r12620 r12630  
    5151import org.openstreetmap.josm.data.osm.OsmPrimitive;
    5252import org.openstreetmap.josm.gui.ExtendedDialog;
     53import org.openstreetmap.josm.gui.MainApplication;
     54import org.openstreetmap.josm.gui.MapFrame;
    5355import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    5456import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSException;
     
    696698        public void receiveSearchResult(DataSet ds, Collection<OsmPrimitive> result, int foundMatches, SearchSetting setting) {
    697699            ds.setSelected(result);
     700            MapFrame map = MainApplication.getMap();
    698701            if (foundMatches == 0) {
    699702                final String msg;
     
    710713                    msg = null;
    711714                }
    712                 if (Main.map != null) {
    713                     Main.map.statusLine.setHelpText(msg);
     715                if (map != null) {
     716                    map.statusLine.setHelpText(msg);
    714717                }
    715718                if (!GraphicsEnvironment.isHeadless()) {
     
    722725                }
    723726            } else {
    724                 Main.map.statusLine.setHelpText(tr("Found {0} matches", foundMatches));
     727                map.statusLine.setHelpText(tr("Found {0} matches", foundMatches));
    725728            }
    726729        }
  • trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

    r12620 r12630  
    3636import org.openstreetmap.josm.data.osm.Tagged;
    3737import org.openstreetmap.josm.data.osm.Way;
     38import org.openstreetmap.josm.gui.MainApplication;
    3839import org.openstreetmap.josm.gui.mappaint.Environment;
    3940import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
     
    15511552        @Override
    15521553        protected Collection<Bounds> getBounds(OsmPrimitive primitive) {
    1553             if (!Main.isDisplayingMapView()) {
     1554            if (!MainApplication.isDisplayingMapView()) {
    15541555                return null;
    15551556            }
    1556             return Collections.singleton(Main.map.mapView.getRealBounds());
     1557            return Collections.singleton(MainApplication.getMap().mapView.getRealBounds());
    15571558        }
    15581559
  • trunk/src/org/openstreetmap/josm/actions/upload/UploadNotesTask.java

    r12620 r12630  
    1515import org.openstreetmap.josm.data.osm.NoteData;
    1616import org.openstreetmap.josm.gui.ExceptionDialogUtil;
     17import org.openstreetmap.josm.gui.MainApplication;
    1718import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1819import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     
    123124                StringBuilder sb = new StringBuilder();
    124125                for (Map.Entry<Note, Exception> entry : failedNotes.entrySet()) {
    125                     sb.append(tr("Note {0} failed: {1}", entry.getKey().getId(), entry.getValue().getMessage()));
    126                     sb.append('\n');
     126                    sb.append(tr("Note {0} failed: {1}", entry.getKey().getId(), entry.getValue().getMessage()))
     127                      .append('\n');
    127128                }
    128129                Logging.error("Notes failed to upload: " + sb.toString());
    129                 JOptionPane.showMessageDialog(Main.map, sb.toString(), tr("Notes failed to upload"), JOptionPane.ERROR_MESSAGE);
     130                JOptionPane.showMessageDialog(MainApplication.getMap(), sb.toString(),
     131                        tr("Notes failed to upload"), JOptionPane.ERROR_MESSAGE);
    130132                ExceptionDialogUtil.explainException(failedNotes.values().iterator().next());
    131133            }
  • trunk/src/org/openstreetmap/josm/actions/upload/ValidateUploadHook.java

    r12279 r12630  
    2222import org.openstreetmap.josm.data.validation.util.AggregatePrimitivesVisitor;
    2323import org.openstreetmap.josm.gui.ExtendedDialog;
     24import org.openstreetmap.josm.gui.MainApplication;
     25import org.openstreetmap.josm.gui.MapFrame;
    2426import org.openstreetmap.josm.gui.dialogs.validator.ValidatorTreePanel;
    2527import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    7779            editLayer.validationErrors.addAll(errors);
    7880        }
    79         if (Main.map != null) {
    80             Main.map.validatorDialog.tree.setErrors(errors);
     81        MapFrame map = MainApplication.getMap();
     82        if (map != null) {
     83            map.validatorDialog.tree.setErrors(errors);
    8184        }
    8285        if (errors.isEmpty())
     
    148151            OsmValidator.initializeTests();
    149152            OsmValidator.initializeErrorLayer();
    150             Main.map.validatorDialog.unfurlDialog();
     153            MainApplication.getMap().validatorDialog.unfurlDialog();
    151154            Main.getLayerManager().getLayersOfType(ValidatorLayer.class).forEach(ValidatorLayer::invalidate);
    152155            return false;
  • trunk/src/org/openstreetmap/josm/command/conflict/ConflictAddCommand.java

    r12620 r12630  
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1616import org.openstreetmap.josm.gui.DefaultNameFormatter;
     17import org.openstreetmap.josm.gui.MainApplication;
    1718import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1819import org.openstreetmap.josm.tools.ImageProvider;
     
    6465    @Override
    6566    public void undoCommand() {
    66         if (Main.isDisplayingMapView() && !Main.getLayerManager().containsLayer(getLayer())) {
     67        if (MainApplication.isDisplayingMapView() && !Main.getLayerManager().containsLayer(getLayer())) {
    6768            Logging.warn(tr("Layer ''{0}'' does not exist any more. Cannot remove conflict for object ''{1}''.",
    6869                    getLayer().getName(),
  • trunk/src/org/openstreetmap/josm/command/conflict/ConflictResolveCommand.java

    r12620 r12630  
    1010import org.openstreetmap.josm.data.conflict.Conflict;
    1111import org.openstreetmap.josm.data.conflict.ConflictCollection;
     12import org.openstreetmap.josm.gui.MainApplication;
    1213import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1314import org.openstreetmap.josm.tools.Logging;
     
    7172        super.undoCommand();
    7273
    73         if (Main.isDisplayingMapView()) {
     74        if (MainApplication.isDisplayingMapView()) {
    7475            if (!Main.getLayerManager().containsLayer(getLayer())) {
    7576                Logging.warn(tr("Cannot undo command ''{0}'' because layer ''{1}'' is not present any more",
  • trunk/src/org/openstreetmap/josm/data/imagery/OffsetBookmark.java

    r12620 r12630  
    1919import org.openstreetmap.josm.data.projection.Projection;
    2020import org.openstreetmap.josm.data.projection.Projections;
     21import org.openstreetmap.josm.gui.MainApplication;
    2122import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
    2223import org.openstreetmap.josm.gui.layer.ImageryLayer;
     
    246247    public static void bookmarkOffset(String name, AbstractTileSourceLayer layer) {
    247248        LatLon center;
    248         if (Main.isDisplayingMapView()) {
    249             center = Main.getProjection().eastNorth2latlon(Main.map.mapView.getCenter());
     249        if (MainApplication.isDisplayingMapView()) {
     250            center = Main.getProjection().eastNorth2latlon(MainApplication.getMap().mapView.getCenter());
    250251        } else {
    251252            center = LatLon.ZERO;
  • trunk/src/org/openstreetmap/josm/data/osm/FilterMatcher.java

    r12383 r12630  
    66import java.util.List;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.actions.search.SearchAction.SearchMode;
    109import org.openstreetmap.josm.actions.search.SearchCompiler;
     
    1211import org.openstreetmap.josm.actions.search.SearchCompiler.Not;
    1312import org.openstreetmap.josm.actions.search.SearchCompiler.ParseError;
     13import org.openstreetmap.josm.gui.MainApplication;
     14import org.openstreetmap.josm.gui.MapFrame;
    1415import org.openstreetmap.josm.tools.SubclassFilteredCollection;
    1516
     
    224225
    225226    private static FilterType test(List<FilterInfo> filters, OsmPrimitive primitive, boolean hidden) {
    226 
     227        MapFrame map = MainApplication.getMap();
    227228        if (primitive.isIncomplete() ||
    228                 (Main.map != null && Main.map.mapMode != null && Main.map.mapMode.getPreservedPrimitives().contains(primitive)))
     229                (map != null && map.mapMode != null && map.mapMode.getPreservedPrimitives().contains(primitive)))
    229230            return FilterType.NOT_FILTERED;
    230231
  • trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java

    r12620 r12630  
    1919import org.openstreetmap.josm.actions.search.SearchCompiler.ParseError;
    2020import org.openstreetmap.josm.data.osm.Filter.FilterPreferenceEntry;
     21import org.openstreetmap.josm.gui.MainApplication;
    2122import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2223import org.openstreetmap.josm.gui.widgets.OSDLabel;
     
    323324        lblOSD.setSize(lblOSD.getPreferredSize());
    324325
    325         int dx = Main.map.mapView.getWidth() - lblOSD.getPreferredSize().width - 15;
     326        int dx = MainApplication.getMap().mapView.getWidth() - lblOSD.getPreferredSize().width - 15;
    326327        int dy = 15;
    327328        g.translate(dx, dy);
  • trunk/src/org/openstreetmap/josm/data/osm/NoteData.java

    r12620 r12630  
    1010import java.util.Map;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.coor.LatLon;
    1413import org.openstreetmap.josm.data.notes.Note;
     
    1615import org.openstreetmap.josm.data.notes.NoteComment;
    1716import org.openstreetmap.josm.gui.JosmUserIdentityManager;
     17import org.openstreetmap.josm.gui.MainApplication;
     18import org.openstreetmap.josm.gui.MapFrame;
    1819import org.openstreetmap.josm.tools.ListenerList;
    1920import org.openstreetmap.josm.tools.Logging;
     
    8586    }
    8687
    87     /** Returns the currently selected note
     88    /**
     89     * Returns the currently selected note
    8890     * @return currently selected note
    8991     */
     
    9294    }
    9395
    94     /** Set a selected note. Causes the dialog to select the note and
     96    /**
     97     * Set a selected note. Causes the dialog to select the note and
    9598     * the note layer to draw the selected note's comments.
    9699     * @param note Selected note. Null indicates no selection
     
    98101    public void setSelectedNote(Note note) {
    99102        selectedNote = note;
    100         if (Main.map != null) {
    101             Main.map.noteDialog.selectionChanged();
     103        MapFrame map = MainApplication.getMap();
     104        if (map != null) {
     105            map.noteDialog.selectionChanged();
    102106        }
    103107        listeners.fireEvent(l -> l.selectedNoteChanged(this));
     
    232236
    233237    private void dataUpdated() {
    234         if (Main.isDisplayingMapView()) {
    235             Main.map.noteDialog.setNotes(getSortedNotes());
     238        if (MainApplication.isDisplayingMapView()) {
     239            MainApplication.getMap().noteDialog.setNotes(getSortedNotes());
    236240        }
    237241        listeners.fireEvent(l -> l.noteDataUpdated(this));
  • trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java

    r12190 r12630  
    1818import org.openstreetmap.josm.data.osm.PrimitiveId;
    1919import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
     20import org.openstreetmap.josm.gui.MainApplication;
    2021import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
    2122import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
     
    226227    @Override
    227228    public void layerRemoving(LayerRemoveEvent e) {
    228         if (!Main.isDisplayingMapView()) return;
     229        if (!MainApplication.isDisplayingMapView()) return;
    229230        if (Main.getLayerManager().getLayers().isEmpty()) {
    230231            data.clear();
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitor.java

    r12163 r12630  
    1515import org.openstreetmap.josm.data.osm.RelationMember;
    1616import org.openstreetmap.josm.data.osm.Way;
     17import org.openstreetmap.josm.gui.MainApplication;
     18import org.openstreetmap.josm.gui.MapFrame;
    1719
    1820/**
     
    197199            return;
    198200        // convert size from meters to east/north units
    199         double enSize = size * Main.map.mapView.getScale() / Main.map.mapView.getDist100Pixel() * 100;
     201        MapFrame map = MainApplication.getMap();
     202        double enSize = size * map.mapView.getScale() / map.mapView.getDist100Pixel() * 100;
    200203        visit(bounds.getMin().add(-enSize/2, -enSize/2));
    201204        visit(bounds.getMax().add(+enSize/2, +enSize/2));
  • trunk/src/org/openstreetmap/josm/gui/ImageryMenu.java

    r12125 r12630  
    160160        // list all imagery entries where the current map location
    161161        // is within the imagery bounds
    162         if (Main.isDisplayingMapView()) {
    163             MapView mv = Main.map.mapView;
     162        if (MainApplication.isDisplayingMapView()) {
     163            MapView mv = MainApplication.getMap().mapView;
    164164            LatLon pos = mv.getProjection().eastNorth2latlon(mv.getCenter());
    165165            final List<ImageryInfo> inViewLayers = new ArrayList<>();
  • trunk/src/org/openstreetmap/josm/gui/MainApplication.java

    r12629 r12630  
    106106    private static final List<String> COMMAND_LINE_ARGS = new ArrayList<>();
    107107
     108    /**
     109     * The MapFrame.
     110     */
     111    static MapFrame map;
     112
    108113    private final MainFrame mainFrame;
    109114
     
    225230    public static List<String> getCommandLineArgs() {
    226231        return Collections.unmodifiableList(COMMAND_LINE_ARGS);
     232    }
     233
     234    /**
     235     * Returns the MapFrame.
     236     * <p>
     237     * There should be no need to access this to access any map data. Use {@link #layerManager} instead.
     238     * @return the MapFrame
     239     * @see MainPanel
     240     * @since 12630 (as a replacement to {@code Main.map})
     241     */
     242    public static MapFrame getMap() {
     243        return map;
     244    }
     245
     246    /**
     247     * Replies true if JOSM currently displays a map view. False, if it doesn't, i.e. if
     248     * it only shows the MOTD panel.
     249     * <p>
     250     * You do not need this when accessing the layer manager. The layer manager will be empty if no map view is shown.
     251     *
     252     * @return <code>true</code> if JOSM currently displays a map view
     253     * @since 12630 (as a replacement to {@code Main.isDisplayingMapView()})
     254     */
     255    @SuppressWarnings("deprecation")
     256    public static boolean isDisplayingMapView() {
     257        return map != null && map.mapView != null;
    227258    }
    228259
  • trunk/src/org/openstreetmap/josm/gui/MainPanel.java

    r11713 r12630  
    4444     * @param showMap If the map should be displayed.
    4545     */
     46    @SuppressWarnings("deprecation")
    4647    protected synchronized void updateContent(boolean showMap) {
    4748        GuiHelper.assertCallFromEdt();
     
    6566            map = null;
    6667            Main.map = map;
     68            MainApplication.map = map;
    6769            add(getGettingStarted(), BorderLayout.CENTER);
    6870        }
     
    8385    }
    8486
     87    @SuppressWarnings("deprecation")
    8588    private MapFrame createNewMapFrame() {
    8689        MapFrame mapFrame = new MapFrame(null);
    8790        // Required by many components.
    8891        Main.map = mapFrame;
     92        MainApplication.map = mapFrame;
    8993
    9094        mapFrame.fillPanel(this);
  • trunk/src/org/openstreetmap/josm/gui/MapMover.java

    r12338 r12630  
    169169        boolean allowMovement = (e.getModifiersEx() & (MouseEvent.BUTTON3_DOWN_MASK | offMask)) == MouseEvent.BUTTON3_DOWN_MASK;
    170170        if (Main.isPlatformOsx()) {
     171            MapFrame map = MainApplication.getMap();
    171172            int macMouseMask = MouseEvent.CTRL_DOWN_MASK | MouseEvent.BUTTON1_DOWN_MASK;
    172173            boolean macMovement = e.getModifiersEx() == macMouseMask;
    173             boolean allowedMode = !Main.map.mapModeSelect.equals(Main.map.mapMode)
    174                               || SelectAction.Mode.SELECT.equals(Main.map.mapModeSelect.getMode());
     174            boolean allowedMode = !map.mapModeSelect.equals(map.mapMode)
     175                              || SelectAction.Mode.SELECT.equals(map.mapModeSelect.getMode());
    175176            allowMovement |= macMovement && allowedMode;
    176177        }
  • trunk/src/org/openstreetmap/josm/gui/MapStatus.java

    r12620 r12630  
    406406                    try {
    407407                        final MouseState ms = incomingMouseState.take();
    408                         if (parent != Main.map)
     408                        if (parent != MainApplication.getMap())
    409409                            return; // exit, if new parent.
    410410
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r12620 r12630  
    562562        }
    563563
     564        MapFrame map = MainApplication.getMap();
    564565        if (AutoFilterManager.getInstance().getCurrentAutoFilter() != null) {
    565566            AutoFilterManager.getInstance().drawOSDText(tempG);
    566         } else if (Main.isDisplayingMapView() && Main.map.filterDialog != null) {
    567             Main.map.filterDialog.drawOSDText(tempG);
     567        } else if (MainApplication.isDisplayingMapView() && map.filterDialog != null) {
     568            map.filterDialog.drawOSDText(tempG);
    568569        }
    569570
     
    660661    @Override
    661662    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
    662         if (Main.map != null) {
     663        MapFrame map = MainApplication.getMap();
     664        if (map != null) {
    663665            /* This only makes the buttons look disabled. Disabling the actions as well requires
    664666             * the user to re-select the tool after i.e. moving a layer. While testing I found
     
    666668             * order. This way it works as visual clue for new users */
    667669            // FIXME: This does not belong here.
    668             for (final AbstractButton b: Main.map.allMapModeButtons) {
     670            for (final AbstractButton b: map.allMapModeButtons) {
    669671                MapMode mode = (MapMode) b.getAction();
    670672                final boolean activeLayerSupported = mode.layerIsSupported(layerManager.getActiveLayer());
  • trunk/src/org/openstreetmap/josm/gui/NotificationManager.java

    r11996 r12630  
    114114                int x;
    115115                int y;
    116                 if (Main.isDisplayingMapView() && Main.map.mapView.getHeight() > 0) {
    117                     MapView mv = Main.map.mapView;
     116                MapFrame map = MainApplication.getMap();
     117                if (MainApplication.isDisplayingMapView() && map.mapView.getHeight() > 0) {
     118                    MapView mv = map.mapView;
    118119                    Point mapViewPos = SwingUtilities.convertPoint(mv.getParent(), mv.getX(), mv.getY(), Main.parent);
    119120                    x = mapViewPos.x + margin;
    120                     y = mapViewPos.y + mv.getHeight() - Main.map.statusLine.getHeight() - size.height - margin;
     121                    y = mapViewPos.y + mv.getHeight() - map.statusLine.getHeight() - size.height - margin;
    121122                } else {
    122123                    x = margin;
  • trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

    r11945 r12630  
    184184    public void mousePressed(MouseEvent e) {
    185185        if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount() > 1 && Main.getLayerManager().getEditDataSet() != null) {
    186             SelectByInternalPointAction.performSelection(Main.map.mapView.getEastNorth(e.getX(), e.getY()),
     186            SelectByInternalPointAction.performSelection(MainApplication.getMap().mapView.getEastNorth(e.getX(), e.getY()),
    187187                    (e.getModifiersEx() & MouseEvent.SHIFT_DOWN_MASK) != 0,
    188188                    (e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) != 0);
  • trunk/src/org/openstreetmap/josm/gui/autofilter/AutoFilterButton.java

    r12474 r12630  
    1111import javax.swing.JButton;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.actions.JosmAction;
    1514import org.openstreetmap.josm.data.preferences.ColorProperty;
     15import org.openstreetmap.josm.gui.MainApplication;
    1616
    1717/**
     
    3636                if (filter.equals(afm.getCurrentAutoFilter())) {
    3737                    afm.setCurrentAutoFilter(null);
    38                     Main.map.filterDialog.getFilterModel().executeFilters();
     38                    MainApplication.getMap().filterDialog.getFilterModel().executeFilters();
    3939                } else {
    4040                    afm.setCurrentAutoFilter(filter);
  • trunk/src/org/openstreetmap/josm/gui/autofilter/AutoFilterManager.java

    r12620 r12630  
    4343import org.openstreetmap.josm.data.preferences.BooleanProperty;
    4444import org.openstreetmap.josm.data.preferences.StringProperty;
     45import org.openstreetmap.josm.gui.MainApplication;
    4546import org.openstreetmap.josm.gui.MapFrame;
    4647import org.openstreetmap.josm.gui.MapFrame.MapModeChangeListener;
     48import org.openstreetmap.josm.gui.MapView;
    4749import org.openstreetmap.josm.gui.NavigatableComponent;
    4850import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
     
    130132
    131133    private synchronized void updateButtons() {
    132         if (enabledRule != null && Main.map != null
    133                 && enabledRule.getMinZoomLevel() <= Selector.GeneralSelector.scale2level(Main.map.mapView.getDist100Pixel())) {
     134        MapFrame map = MainApplication.getMap();
     135        if (enabledRule != null && map != null
     136                && enabledRule.getMinZoomLevel() <= Selector.GeneralSelector.scale2level(map.mapView.getDist100Pixel())) {
    134137            // Retrieve the values from current rule visible on screen
    135138            NavigableSet<String> values = getNumericValues(enabledRule.getKey(), enabledRule.getValueComparator());
     
    148151        int i = 0;
    149152        int maxWidth = 16;
     153        MapView mapView = MainApplication.getMap().mapView;
    150154        for (final String value : values.descendingSet()) {
    151155            Filter filter = new Filter();
     
    161165            buttons.put(value, button);
    162166            maxWidth = Math.max(maxWidth, button.getPreferredSize().width);
    163             Main.map.mapView.add(button).setLocation(3, 60 + 22*i++);
     167            mapView.add(button).setLocation(3, 60 + 22*i++);
    164168        }
    165169        for (AutoFilterButton b : buttons.values()) {
    166170            b.setSize(maxWidth, 20);
    167171        }
    168         Main.map.mapView.validate();
     172        mapView.validate();
    169173    }
    170174
    171175    private void removeAllButtons() {
    172176        for (Iterator<String> it = buttons.keySet().iterator(); it.hasNext();) {
    173             Main.map.mapView.remove(buttons.get(it.next()));
     177            MainApplication.getMap().mapView.remove(buttons.get(it.next()));
    174178            it.remove();
    175179        }
     
    193197        Set<String> values = new TreeSet<>();
    194198        if (ds != null) {
    195             BBox bbox = Main.map.mapView.getState().getViewArea().getLatLonBoundsBox().toBBox();
     199            BBox bbox = MainApplication.getMap().mapView.getState().getViewArea().getLatLonBoundsBox().toBBox();
    196200            Consumer<OsmPrimitive> consumer = getTagValuesConsumer(key, values);
    197201            ds.searchNodes(bbox).forEach(consumer);
     
    388392        setCurrentAutoFilter(null);
    389393        removeAllButtons();
    390         if (Main.map != null) {
    391             Main.map.filterDialog.getFilterModel().executeFilters();
     394        MapFrame map = MainApplication.getMap();
     395        if (map != null) {
     396            map.filterDialog.getFilterModel().executeFilters();
    392397        }
    393398    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/CommandStackDialog.java

    r12279 r12630  
    4242import org.openstreetmap.josm.data.osm.DataSet;
    4343import org.openstreetmap.josm.data.osm.OsmPrimitive;
     44import org.openstreetmap.josm.gui.MainApplication;
    4445import org.openstreetmap.josm.gui.SideButton;
    4546import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    463464                break;
    464465            }
    465             Main.map.repaint();
     466            MainApplication.getMap().repaint();
    466467        }
    467468
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r12620 r12630  
    5656import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    5757import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     58import org.openstreetmap.josm.gui.MainApplication;
    5859import org.openstreetmap.josm.gui.NavigatableComponent;
    5960import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
     
    130131            lstConflicts.addMouseListener(new MouseEventHandler());
    131132        }
    132         addListSelectionListener(e -> Main.map.mapView.repaint());
     133        addListSelectionListener(e -> MainApplication.getMap().mapView.repaint());
    133134
    134135        SideButton btnResolve = new SideButton(actResolve);
     
    210211            lstConflicts.setSelectedIndex(index);
    211212        }
    212         Main.map.mapView.repaint();
     213        MainApplication.getMap().mapView.repaint();
    213214    }
    214215
     
    632633                );
    633634                unfurlDialog();
    634                 Main.map.repaint();
     635                MainApplication.getMap().repaint();
    635636            });
    636637        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterDialog.java

    r12400 r12630  
    4040import org.openstreetmap.josm.data.osm.event.TagsChangedEvent;
    4141import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
     42import org.openstreetmap.josm.gui.MainApplication;
    4243import org.openstreetmap.josm.gui.MapFrame;
    4344import org.openstreetmap.josm.gui.MapFrame.MapModeChangeListener;
     
    8889        MapFrame.removeMapModeChangeListener(this);
    8990        filterModel.model.clearFilterFlags();
    90         Main.map.mapView.repaint();
     91        MainApplication.getMap().mapView.repaint();
    9192    }
    9293
  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterTableModel.java

    r12620 r12630  
    1111import javax.swing.table.AbstractTableModel;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.osm.Filter;
    1514import org.openstreetmap.josm.data.osm.FilterModel;
    1615import org.openstreetmap.josm.data.osm.OsmPrimitive;
     16import org.openstreetmap.josm.gui.MainApplication;
     17import org.openstreetmap.josm.gui.MapFrame;
    1718import org.openstreetmap.josm.gui.autofilter.AutoFilterManager;
    1819import org.openstreetmap.josm.gui.widgets.OSDLabel;
     
    8788
    8889    private void updateMap() {
    89         if (Main.map != null && model.isChanged()) {
    90             Main.map.filterDialog.updateDialogHeader();
     90        MapFrame map = MainApplication.getMap();
     91        if (map != null && model.isChanged()) {
     92            map.filterDialog.updateDialogHeader();
    9193        }
    9294    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDialog.java

    r12279 r12630  
    2626import org.openstreetmap.josm.gui.DefaultNameFormatter;
    2727import org.openstreetmap.josm.gui.ExtendedDialog;
     28import org.openstreetmap.josm.gui.MainApplication;
    2829import org.openstreetmap.josm.gui.NavigatableComponent;
    2930import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    116117        final Collection<OsmPrimitive> sel = Main.getLayerManager().getEditDataSet().getAllSelected();
    117118        ElemStyles elemstyles = MapPaintStyles.getStyles();
    118         NavigatableComponent nc = Main.map.mapView;
     119        NavigatableComponent nc = MainApplication.getMap().mapView;
    119120        double scale = nc.getDist100Pixel();
    120121
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r11905 r12630  
    4444import org.openstreetmap.josm.actions.MergeLayerAction;
    4545import org.openstreetmap.josm.data.preferences.AbstractProperty;
     46import org.openstreetmap.josm.gui.MainApplication;
     47import org.openstreetmap.josm.gui.MapFrame;
    4648import org.openstreetmap.josm.gui.MapView;
    4749import org.openstreetmap.josm.gui.SideButton;
     
    507509            Layer layer = (Layer) value;
    508510            if (layer instanceof NativeScaleLayer) {
    509                 boolean active = ((NativeScaleLayer) layer) == Main.map.mapView.getNativeScaleLayer();
     511                boolean active = ((NativeScaleLayer) layer) == MainApplication.getMap().mapView.getNativeScaleLayer();
    510512                cb.setSelected(active);
    511513                cb.setToolTipText(active
     
    824826            List<Integer> sel = getSelectedRows();
    825827            List<Layer> layers = getLayers();
     828            MapView mapView = MainApplication.getMap().mapView;
    826829            for (int row : sel) {
    827830                Layer l1 = layers.get(row);
    828831                Layer l2 = layers.get(row-1);
    829                 Main.map.mapView.moveLayer(l2, row);
    830                 Main.map.mapView.moveLayer(l1, row-1);
     832                mapView.moveLayer(l2, row);
     833                mapView.moveLayer(l1, row-1);
    831834            }
    832835            fireTableDataChanged();
     
    859862            Collections.reverse(sel);
    860863            List<Layer> layers = getLayers();
     864            MapView mapView = MainApplication.getMap().mapView;
    861865            for (int row : sel) {
    862866                Layer l1 = layers.get(row);
    863867                Layer l2 = layers.get(row+1);
    864                 Main.map.mapView.moveLayer(l1, row+1);
    865                 Main.map.mapView.moveLayer(l2, row);
     868                mapView.moveLayer(l1, row+1);
     869                mapView.moveLayer(l2, row);
    866870            }
    867871            fireTableDataChanged();
     
    9991003                    break;
    10001004                case 1:
    1001                     NativeScaleLayer oldLayer = Main.map.mapView.getNativeScaleLayer();
     1005                    MapFrame map = MainApplication.getMap();
     1006                    NativeScaleLayer oldLayer = map.mapView.getNativeScaleLayer();
    10021007                    if (oldLayer == l) {
    1003                         Main.map.mapView.setNativeScaleLayer(null);
     1008                        map.mapView.setNativeScaleLayer(null);
    10041009                    } else if (l instanceof NativeScaleLayer) {
    1005                         Main.map.mapView.setNativeScaleLayer((NativeScaleLayer) l);
     1010                        map.mapView.setNativeScaleLayer((NativeScaleLayer) l);
    10061011                        if (oldLayer != null) {
    10071012                            int idx = getLayers().indexOf(oldLayer);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/MinimapDialog.java

    r11452 r12630  
    88import java.util.Collections;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.Bounds;
     11import org.openstreetmap.josm.gui.MainApplication;
    1212import org.openstreetmap.josm.gui.MapView;
    1313import org.openstreetmap.josm.gui.NavigatableComponent;
     
    5555    @Override
    5656    public void zoomChanged() {
    57         if (!skipEvents && Main.isDisplayingMapView()) {
    58             MapView mv = Main.map.mapView;
     57        if (!skipEvents && MainApplication.isDisplayingMapView()) {
     58            MapView mv = MainApplication.getMap().mapView;
    5959            final Bounds currentBounds = new Bounds(
    6060                    mv.getLatLon(0, mv.getHeight()),
     
    7272        if (!skipEvents) {
    7373            skipEvents = true;
    74             Main.map.mapView.zoomTo(slippyMap.getBoundingBox());
     74            MainApplication.getMap().mapView.zoomTo(slippyMap.getBoundingBox());
    7575            skipEvents = false;
    7676        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/NotesDialog.java

    r12279 r12630  
    3636import org.openstreetmap.josm.data.notes.NoteComment;
    3737import org.openstreetmap.josm.data.osm.NoteData;
     38import org.openstreetmap.josm.gui.MainApplication;
     39import org.openstreetmap.josm.gui.MapFrame;
    3840import org.openstreetmap.josm.gui.NoteInputDialog;
    3941import org.openstreetmap.josm.gui.NoteSortDialog;
     
    99101            public void mouseClicked(MouseEvent e) {
    100102                if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2 && noteData != null && noteData.getSelectedNote() != null) {
    101                     Main.map.mapView.zoomTo(noteData.getSelectedNote().getLatLon());
     103                    MainApplication.getMap().mapView.zoomTo(noteData.getSelectedNote().getLatLon());
    102104                }
    103105            }
     
    161163            noteData = null;
    162164            model.clearData();
    163             if (Main.map.mapMode instanceof AddNoteAction) {
    164                 Main.map.selectMapMode(Main.map.mapModeSelect);
     165            MapFrame map = MainApplication.getMap();
     166            if (map.mapMode instanceof AddNoteAction) {
     167                map.selectMapMode(map.mapModeSelect);
    165168            }
    166169        }
     
    297300            Note note = displayList.getSelectedValue();
    298301            if (note == null) {
    299                 JOptionPane.showMessageDialog(Main.map,
     302                JOptionPane.showMessageDialog(MainApplication.getMap(),
    300303                        "You must select a note first",
    301304                        "No note selected",
     
    355358                Main.getLayerManager().addLayer(new NoteLayer());
    356359            }
    357             Main.map.selectMapMode(new AddNoteAction(noteData));
     360            MainApplication.getMap().selectMapMode(new AddNoteAction(noteData));
    358361        }
    359362    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r12528 r12630  
    5757import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
    5858import org.openstreetmap.josm.gui.DefaultNameFormatter;
     59import org.openstreetmap.josm.gui.MainApplication;
    5960import org.openstreetmap.josm.gui.MapView;
    6061import org.openstreetmap.josm.gui.NavigatableComponent;
     
    209210
    210211        //update highlights
    211         if (highlightEnabled && focused == displaylist && Main.isDisplayingMapView() && highlightHelper.highlightOnly(sel)) {
    212             Main.map.mapView.repaint();
     212        if (highlightEnabled && focused == displaylist && MainApplication.isDisplayingMapView() && highlightHelper.highlightOnly(sel)) {
     213            MainApplication.getMap().mapView.repaint();
    213214        }
    214215    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r12279 r12630  
    6767import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    6868import org.openstreetmap.josm.gui.DefaultNameFormatter;
     69import org.openstreetmap.josm.gui.MainApplication;
     70import org.openstreetmap.josm.gui.MapFrame;
    6971import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    7072import org.openstreetmap.josm.gui.PopupMenuHandler;
     
    212214                    actEditRelationSelection.actionPerformed(null);
    213215                }
    214             } else if (highlightEnabled && Main.isDisplayingMapView() && helper.highlightOnly(model.getElementAt(idx))) {
    215                 Main.map.mapView.repaint();
     216            } else if (highlightEnabled && MainApplication.isDisplayingMapView() && helper.highlightOnly(model.getElementAt(idx))) {
     217                MainApplication.getMap().mapView.repaint();
    216218            }
    217219        }
     
    442444                return;
    443445            box.enlargeBoundingBox();
    444             Main.map.mapView.zoomTo(box);
     446            MainApplication.getMap().mapView.zoomTo(box);
    445447        }
    446448
     
    615617                    if (selection != null) {
    616618                        remember(selection);
     619                        MapFrame map = MainApplication.getMap();
    617620                        if (selection.size() == 2) {
    618621                            Iterator<? extends OsmPrimitive> it = selection.iterator();
     
    624627                                LatLon c2 = ((Node) n2).getCoor();
    625628                                if (c1 != null && c2 != null) {
    626                                     Main.map.statusLine.setDist(c1.greatCircleDistance(c2));
     629                                    map.statusLine.setDist(c1.greatCircleDistance(c2));
    627630                                    return;
    628631                                }
    629632                            }
    630633                        }
    631                         Main.map.statusLine.setDist(
     634                        map.statusLine.setDist(
    632635                                new SubclassFilteredCollection<OsmPrimitive, Way>(selection, Way.class::isInstance));
    633636                    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

    r12302 r12630  
    4343import org.openstreetmap.josm.data.validation.TestError;
    4444import org.openstreetmap.josm.data.validation.ValidatorVisitor;
     45import org.openstreetmap.josm.gui.MainApplication;
     46import org.openstreetmap.josm.gui.MapFrame;
    4547import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    4648import org.openstreetmap.josm.gui.PopupMenuHandler;
     
    315317            tree.resetErrors();
    316318            OsmValidator.saveIgnoredErrors();
    317             Main.map.repaint();
     319            MainApplication.getMap().repaint();
    318320        }
    319321    }
     
    524526            fixButton.setEnabled(hasFixes);
    525527            popupMenuHandler.setPrimitives(sel);
    526             if (Main.map != null) {
    527                 Main.map.repaint();
     528            MapFrame map = MainApplication.getMap();
     529            if (map != null) {
     530                map.repaint();
    528531            }
    529532        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/BasicChangesetQueryPanel.java

    r12620 r12630  
    2222import org.openstreetmap.josm.data.Bounds;
    2323import org.openstreetmap.josm.gui.JosmUserIdentityManager;
     24import org.openstreetmap.josm.gui.MainApplication;
     25import org.openstreetmap.josm.gui.MapView;
    2426import org.openstreetmap.josm.gui.widgets.HtmlPanel;
    2527import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     
    165167        }
    166168
    167         // query for changesets in the current map view only if there *is* a current
    168         // map view
     169        // query for changesets in the current map view only if there *is* a current map view
    169170        lbl = lblQueries.get(BasicQuery.CHANGESETS_IN_MAP_VIEW);
    170         if (!Main.isDisplayingMapView()) {
     171        if (!MainApplication.isDisplayingMapView()) {
    171172            rbQueries.get(BasicQuery.CHANGESETS_IN_MAP_VIEW).setEnabled(false);
    172173            lbl.setText(tr("<html>Download changesets in the current map view.<br><em>Disabled. " +
     
    241242            break;
    242243        case CHANGESETS_IN_MAP_VIEW:
    243             Bounds b = Main.map.mapView.getLatLonBounds(Main.map.mapView.getBounds());
     244            MapView mapView = MainApplication.getMap().mapView;
     245            Bounds b = mapView.getLatLonBounds(mapView.getBounds());
    244246            query = query.inBbox(b);
    245247            break;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r12620 r12630  
    8383import org.openstreetmap.josm.gui.DefaultNameFormatter;
    8484import org.openstreetmap.josm.gui.ExtendedDialog;
     85import org.openstreetmap.josm.gui.MainApplication;
    8586import org.openstreetmap.josm.gui.PopupMenuHandler;
    8687import org.openstreetmap.josm.gui.SideButton;
     
    385386            public void mouseClicked(MouseEvent e) {
    386387                //update highlights
    387                 if (Main.isDisplayingMapView()) {
     388                if (MainApplication.isDisplayingMapView()) {
    388389                    int row = membershipTable.rowAtPoint(e.getPoint());
    389390                    if (row >= 0 && highlightHelper.highlightOnly((Relation) membershipTable.getValueAt(row, 0))) {
    390                         Main.map.mapView.repaint();
     391                        MainApplication.getMap().mapView.repaint();
    391392                    }
    392393                }
     
    484485    private void editMembership(int row) {
    485486        Relation relation = (Relation) membershipData.getValueAt(row, 0);
    486         Main.map.relationListDialog.selectRelation(relation);
     487        MainApplication.getMap().relationListDialog.selectRelation(relation);
    487488        RelationEditor.getEditor(
    488489                Main.getLayerManager().getEditLayer(),
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ChildRelationBrowser.java

    r12620 r12630  
    3636import org.openstreetmap.josm.gui.DefaultNameFormatter;
    3737import org.openstreetmap.josm.gui.ExceptionDialogUtil;
     38import org.openstreetmap.josm.gui.MainApplication;
    3839import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    3940import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    420421                    refreshView(r);
    421422                }
    422                 SwingUtilities.invokeLater(Main.map::repaint);
     423                SwingUtilities.invokeLater(MainApplication.getMap()::repaint);
    423424            } catch (OsmTransferException e) {
    424425                if (canceled) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationMemberTask.java

    r12620 r12630  
    1313import javax.swing.SwingUtilities;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.DataSet;
    1716import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1918import org.openstreetmap.josm.gui.DefaultNameFormatter;
    2019import org.openstreetmap.josm.gui.ExceptionDialogUtil;
     20import org.openstreetmap.josm.gui.MainApplication;
    2121import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2222import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    8383    @Override
    8484    protected void finish() {
    85         Main.map.repaint();
     85        MainApplication.getMap().repaint();
    8686        if (canceled)
    8787            return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationTask.java

    r12620 r12630  
    1010import javax.swing.SwingUtilities;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.osm.DataSet;
    1413import org.openstreetmap.josm.data.osm.DataSetMerger;
     
    1615import org.openstreetmap.josm.gui.DefaultNameFormatter;
    1716import org.openstreetmap.josm.gui.ExceptionDialogUtil;
     17import org.openstreetmap.josm.gui.MainApplication;
    1818import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1919import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    102102                layer.mergeFrom(allDownloads);
    103103                layer.onPostDownloadFromServer();
    104                 Main.map.repaint();
     104                MainApplication.getMap().repaint();
    105105            });
    106106        } catch (OsmTransferException | InvocationTargetException | InterruptedException e) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTable.java

    r10683 r12630  
    2828import org.openstreetmap.josm.data.osm.RelationMember;
    2929import org.openstreetmap.josm.data.osm.Way;
     30import org.openstreetmap.josm.gui.MainApplication;
    3031import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType;
    3132import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType.Direction;
     
    108109
    109110    private transient ListSelectionListener highlighterListener = lse -> {
    110         if (Main.isDisplayingMapView()) {
     111        if (MainApplication.isDisplayingMapView()) {
    111112            Collection<RelationMember> sel = getMemberTableModel().getSelectedMembers();
    112113            final Set<OsmPrimitive> toHighlight = new HashSet<>();
     
    117118            }
    118119            SwingUtilities.invokeLater(() -> {
    119                 if (Main.isDisplayingMapView() && highlightHelper.highlightOnly(toHighlight)) {
    120                     Main.map.mapView.repaint();
     120                if (MainApplication.isDisplayingMapView() && highlightHelper.highlightOnly(toHighlight)) {
     121                    MainApplication.getMap().mapView.repaint();
    121122                }
    122123            });
     
    128129        if (!highlightEnabled) return;
    129130        getMemberTableModel().getSelectionModel().addListSelectionListener(highlighterListener);
    130         if (Main.isDisplayingMapView()) {
     131        if (MainApplication.isDisplayingMapView()) {
    131132            HighlightHelper.clearAllHighlighted();
    132             Main.map.mapView.repaint();
     133            MainApplication.getMap().mapView.repaint();
    133134        }
    134135    }
     
    153154        getMemberTableModel().getSelectionModel().removeListSelectionListener(highlighterListener);
    154155        highlighterListener = null;
    155         if (Main.isDisplayingMapView()) {
     156        if (MainApplication.isDisplayingMapView()) {
    156157            HighlightHelper.clearAllHighlighted();
    157             Main.map.mapView.repaint();
     158            MainApplication.getMap().mapView.repaint();
    158159        }
    159160    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/SavingAction.java

    r12048 r12630  
    2121import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2222import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     23import org.openstreetmap.josm.gui.MainApplication;
    2324import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    2425import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
     
    8283        }
    8384        // Relation list gets update in EDT so selecting my be postponed to following EDT run
    84         SwingUtilities.invokeLater(() -> Main.map.relationListDialog.selectRelation(newRelation));
     85        SwingUtilities.invokeLater(() -> MainApplication.getMap().relationListDialog.selectRelation(newRelation));
    8586    }
    8687
     
    140141        );
    141142        if (ret == 0) {
    142             Main.map.conflictDialog.unfurlDialog();
     143            MainApplication.getMap().conflictDialog.unfurlDialog();
    143144        }
    144145        return ret == 0;
  • trunk/src/org/openstreetmap/josm/gui/download/DownloadDialog.java

    r12620 r12630  
    3939import org.openstreetmap.josm.data.preferences.BooleanProperty;
    4040import org.openstreetmap.josm.data.preferences.IntegerProperty;
     41import org.openstreetmap.josm.gui.MainApplication;
    4142import org.openstreetmap.josm.gui.MapView;
    4243import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
     
    408409        tpDownloadAreaSelectors.setSelectedIndex(idx);
    409410
    410         if (Main.isDisplayingMapView()) {
    411             MapView mv = Main.map.mapView;
     411        if (MainApplication.isDisplayingMapView()) {
     412            MapView mv = MainApplication.getMap().mapView;
    412413            currentBounds = new Bounds(
    413414                    mv.getLatLon(0, mv.getHeight()),
  • trunk/src/org/openstreetmap/josm/gui/io/AbstractPrimitiveTask.java

    r10611 r12630  
    77import java.util.Set;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.actions.AutoScaleAction;
    1110import org.openstreetmap.josm.data.osm.DataSet;
     
    1615import org.openstreetmap.josm.data.osm.Way;
    1716import org.openstreetmap.josm.gui.ExceptionDialogUtil;
     17import org.openstreetmap.josm.gui.MainApplication;
    1818import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1919import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    186186        GuiHelper.runInEDTAndWait(() -> {
    187187            layer.mergeFrom(ds);
    188             if (zoom && Main.map != null)
     188            if (zoom && MainApplication.getMap() != null)
    189189                AutoScaleAction.zoomTo(ds.allPrimitives());
    190190            layer.onPostDownloadFromServer();
  • trunk/src/org/openstreetmap/josm/gui/io/BasicUploadSettingsPanel.java

    r12370 r12630  
    2828import org.openstreetmap.josm.Main;
    2929import org.openstreetmap.josm.data.osm.Changeset;
     30import org.openstreetmap.josm.gui.MainApplication;
    3031import org.openstreetmap.josm.gui.widgets.HistoryComboBox;
    3132import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     
    8485        sourceLabel.addHyperlinkListener(e -> {
    8586            if (HyperlinkEvent.EventType.ACTIVATED.equals(e.getEventType())) {
    86                 final String source = Main.map.mapView.getLayerInformationForSourceTag();
     87                final String source = MainApplication.getMap().mapView.getLayerInformationForSourceTag();
    8788                hcbUploadSource.setText(Utils.shortenString(source, Changeset.MAX_CHANGESET_TAG_LENGTH));
    8889                // Fix #9965
  • trunk/src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

    r12620 r12630  
    8989import org.openstreetmap.josm.data.projection.Projections;
    9090import org.openstreetmap.josm.gui.ExtendedDialog;
     91import org.openstreetmap.josm.gui.MainApplication;
    9192import org.openstreetmap.josm.gui.MapView;
    9293import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
     
    261262
    262263    protected void initTileSource(T tileSource) {
    263         coordinateConverter = new TileCoordinateConverter(Main.map.mapView, tileSource, getDisplaySettings());
     264        coordinateConverter = new TileCoordinateConverter(MainApplication.getMap().mapView, tileSource, getDisplaySettings());
    264265        attribution.initialize(tileSource);
    265266
     
    852853
    853854    private TileSet getVisibleTileSet() {
    854         ProjectionBounds bounds = Main.map.mapView.getState().getViewArea().getProjectionBounds();
     855        ProjectionBounds bounds = MainApplication.getMap().mapView.getState().getViewArea().getProjectionBounds();
    855856        return getTileSet(bounds, currentZoomLevel);
    856857    }
     
    987988                drawImageInside(g, img, anchorImage, anchorScreen, null);
    988989            }
    989             if (tile instanceof ReprojectionTile && ((ReprojectionTile) tile).needsUpdate(Main.map.mapView.getScale())) {
     990            MapView mapView = MainApplication.getMap().mapView;
     991            if (tile instanceof ReprojectionTile && ((ReprojectionTile) tile).needsUpdate(mapView.getScale())) {
    990992                // This means we have a reprojected tile in memory cache, but not at
    991993                // current scale. Generally, the positioning of the tile will still
  • trunk/src/org/openstreetmap/josm/gui/layer/AlignImageryPanel.java

    r11386 r12630  
    1515import javax.swing.border.EtchedBorder;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.data.imagery.ImageryInfo;
    1918import org.openstreetmap.josm.data.preferences.BooleanProperty;
     19import org.openstreetmap.josm.gui.MainApplication;
     20import org.openstreetmap.josm.gui.MapFrame;
    2021import org.openstreetmap.josm.gui.util.GuiHelper;
    2122import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     
    5455        closeButton.setToolTipText(tr("Hide this message and never show it again"));
    5556        closeButton.addActionListener(e -> {
    56             if (Main.isDisplayingMapView()) {
    57                 Main.map.removeTopPanel(AlignImageryPanel.class);
     57            if (MainApplication.isDisplayingMapView()) {
     58                MainApplication.getMap().removeTopPanel(AlignImageryPanel.class);
    5859                if (doNotShowAgain.isSelected()) {
    5960                    showAgain.put(Boolean.FALSE);
     
    8384    public static void addNagPanelIfNeeded(ImageryInfo infoToAdd) {
    8485        BooleanProperty showAgain = new BooleanProperty("message.imagery.nagPanel." + infoToAdd.getUrl(), true);
    85         if (Main.isDisplayingMapView() && showAgain.get() && !infoToAdd.isGeoreferenceValid()
    86                 && Main.map.getTopPanel(AlignImageryPanel.class) == null) {
     86        MapFrame map = MainApplication.getMap();
     87        if (MainApplication.isDisplayingMapView() && showAgain.get() && !infoToAdd.isGeoreferenceValid()
     88                && map.getTopPanel(AlignImageryPanel.class) == null) {
    8789            double w = GuiHelper.getScreenSize().getWidth();
    88             Main.map.addTopPanel(new AlignImageryPanel(w > 1300, showAgain, infoToAdd));
     90            map.addTopPanel(new AlignImageryPanel(w > 1300, showAgain, infoToAdd));
    8991        }
    9092    }
  • trunk/src/org/openstreetmap/josm/gui/layer/ImageryLayer.java

    r12460 r12630  
    3535import org.openstreetmap.josm.data.imagery.OffsetBookmark;
    3636import org.openstreetmap.josm.data.preferences.IntegerProperty;
     37import org.openstreetmap.josm.gui.MainApplication;
     38import org.openstreetmap.josm.gui.MapView;
    3739import org.openstreetmap.josm.gui.MenuScroller;
    3840import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
     
    8183
    8284    public double getPPD() {
    83         if (!Main.isDisplayingMapView())
     85        if (!MainApplication.isDisplayingMapView())
    8486            return Main.getProjection().getDefaultZoomInPPD();
    85         ProjectionBounds bounds = Main.map.mapView.getProjectionBounds();
    86         return Main.map.mapView.getWidth() / (bounds.maxEast - bounds.minEast);
     87        MapView mapView = MainApplication.getMap().mapView;
     88        ProjectionBounds bounds = mapView.getProjectionBounds();
     89        return mapView.getWidth() / (bounds.maxEast - bounds.minEast);
    8790    }
    8891
     
    206209            setOffset(b);
    207210            Main.main.menu.imageryMenu.refreshOffsetMenu();
    208             Main.map.repaint();
     211            MainApplication.getMap().repaint();
    209212        }
    210213    }
  • trunk/src/org/openstreetmap/josm/gui/layer/LayerManager.java

    r11905 r12630  
    1212import java.util.function.Consumer;
    1313
    14 import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.gui.MainApplication;
    1515import org.openstreetmap.josm.gui.util.GuiHelper;
    1616import org.openstreetmap.josm.tools.JosmRuntimeException;
     
    232232        insertLayerAt(layer, position);
    233233        fireLayerAdded(layer, initialZoom);
    234         if (Main.map != null) {
     234        if (MainApplication.getMap() != null) {
    235235            layer.hookUpMapView(); // needs to be after fireLayerAdded
    236236        }
  • trunk/src/org/openstreetmap/josm/gui/layer/NoteLayer.java

    r12620 r12630  
    3232import org.openstreetmap.josm.data.osm.NoteData.NoteDataUpdateListener;
    3333import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     34import org.openstreetmap.josm.gui.MainApplication;
    3435import org.openstreetmap.josm.gui.MapView;
    3536import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
     
    7374    @Override
    7475    public void hookUpMapView() {
    75         Main.map.mapView.addMouseListener(this);
     76        MainApplication.getMap().mapView.addMouseListener(this);
    7677    }
    7778
    7879    @Override
    7980    public synchronized void destroy() {
    80         Main.map.mapView.removeMouseListener(this);
     81        MainApplication.getMap().mapView.removeMouseListener(this);
    8182        noteData.removeNoteDataUpdateListener(this);
    8283        super.destroy();
     
    134135            int width = icon.getIconWidth();
    135136            int height = icon.getIconHeight();
    136             g.drawImage(icon.getImage(), p.x - (width / 2), p.y - height, Main.map.mapView);
     137            g.drawImage(icon.getImage(), p.x - (width / 2), p.y - height, MainApplication.getMap().mapView);
    137138        }
    138139        if (noteData.getSelectedNote() != null) {
     
    260261        Note closestNote = null;
    261262        for (Note note : noteData.getNotes()) {
    262             Point notePoint = Main.map.mapView.getPoint(note.getLatLon());
     263            Point notePoint = MainApplication.getMap().mapView.getPoint(note.getLatLon());
    263264            //move the note point to the center of the icon where users are most likely to click when selecting
    264265            notePoint.setLocation(notePoint.getX(), notePoint.getY() - iconHeight / 2);
  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r12620 r12630  
    8787import org.openstreetmap.josm.data.validation.TestError;
    8888import org.openstreetmap.josm.gui.ExtendedDialog;
     89import org.openstreetmap.josm.gui.MainApplication;
     90import org.openstreetmap.josm.gui.MapFrame;
    8991import org.openstreetmap.josm.gui.MapView;
    9092import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
     
    176178    public void setRecentRelation(Relation relation) {
    177179        recentRelations.put(relation, null);
    178         if (Main.map != null && Main.map.relationListDialog != null) {
    179             Main.map.relationListDialog.enableRecentRelations();
     180        MapFrame map = MainApplication.getMap();
     181        if (map != null && map.relationListDialog != null) {
     182            map.relationListDialog.enableRecentRelations();
    180183        }
    181184    }
     
    188191    public void removeRecentRelation(Relation relation) {
    189192        recentRelations.remove(relation);
    190         if (Main.map != null && Main.map.relationListDialog != null) {
    191             Main.map.relationListDialog.enableRecentRelations();
     193        MapFrame map = MainApplication.getMap();
     194        if (map != null && map.relationListDialog != null) {
     195            map.relationListDialog.enableRecentRelations();
    192196        }
    193197    }
     
    478482        Rendering painter = MapRendererFactory.getInstance().createActiveRenderer(g, mv, inactive);
    479483        painter.render(data, virtual, box);
    480         Main.map.conflictDialog.paintConflicts(g, mv);
     484        MainApplication.getMap().conflictDialog.paintConflicts(g, mv);
    481485    }
    482486
     
    571575        invalidate();
    572576        // warn about new conflicts
    573         if (numNewConflicts > 0 && Main.map != null && Main.map.conflictDialog != null) {
    574             Main.map.conflictDialog.warnNumNewConflicts(numNewConflicts);
     577        MapFrame map = MainApplication.getMap();
     578        if (numNewConflicts > 0 && map != null && map.conflictDialog != null) {
     579            map.conflictDialog.warnNumNewConflicts(numNewConflicts);
    575580        }
    576581    }
  • trunk/src/org/openstreetmap/josm/gui/layer/ValidatorLayer.java

    r12028 r12630  
    2222import org.openstreetmap.josm.data.validation.Severity;
    2323import org.openstreetmap.josm.data.validation.TestError;
     24import org.openstreetmap.josm.gui.MainApplication;
    2425import org.openstreetmap.josm.gui.MapView;
    2526import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
     
    4950        super(tr("Validation errors"));
    5051        Main.getLayerManager().addLayerChangeListener(this);
    51         Main.map.validatorDialog.tree.addInvalidationListener(invalidator);
     52        MainApplication.getMap().validatorDialog.tree.addInvalidationListener(invalidator);
    5253    }
    5354
     
    6869    @Override
    6970    public void paint(final Graphics2D g, final MapView mv, Bounds bounds) {
    70         DefaultMutableTreeNode root = Main.map.validatorDialog.tree.getRoot();
     71        DefaultMutableTreeNode root = MainApplication.getMap().validatorDialog.tree.getRoot();
    7172        if (root == null || root.getChildCount() == 0)
    7273            return;
     
    9495    public String getToolTipText() {
    9596        MultiMap<Severity, TestError> errorTree = new MultiMap<>();
    96         List<TestError> errors = Main.map.validatorDialog.tree.getErrors();
     97        List<TestError> errors = MainApplication.getMap().validatorDialog.tree.getErrors();
    9798        for (TestError e : errors) {
    9899            errorTree.put(e.getSeverity(), e);
     
    173174    @Override
    174175    public synchronized void destroy() {
    175         Main.map.validatorDialog.tree.removeInvalidationListener(invalidator);
     176        MainApplication.getMap().validatorDialog.tree.removeInvalidationListener(invalidator);
    176177        Main.getLayerManager().removeLayerChangeListener(this);
    177178        super.destroy();
  • trunk/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java

    r12620 r12630  
    1414import org.openstreetmap.josm.data.imagery.WMTSTileSource;
    1515import org.openstreetmap.josm.data.projection.Projection;
     16import org.openstreetmap.josm.gui.MainApplication;
    1617import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
    1718import org.openstreetmap.josm.tools.Logging;
     
    7172    @Override
    7273    public int getBestZoom() {
    73         if (!Main.isDisplayingMapView())
     74        if (!MainApplication.isDisplayingMapView())
    7475            return 0;
    7576        ScaleList scaleList = getNativeScales();
     
    7778            return getMaxZoomLvl();
    7879        }
    79         double displayScale = Main.map.mapView.getScale();
     80        double displayScale = MainApplication.getMap().mapView.getScale();
    8081        if (coordinateConverter.requiresReprojection()) {
    8182            displayScale *= Main.getProjection().getMetersPerUnit();
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java

    r12620 r12630  
    7171import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    7272import org.openstreetmap.josm.gui.ExtendedDialog;
     73import org.openstreetmap.josm.gui.MainApplication;
    7374import org.openstreetmap.josm.gui.layer.GpxLayer;
    7475import org.openstreetmap.josm.gui.layer.Layer;
     
    194195                    BoundingXYVisitor bbox = new BoundingXYVisitor();
    195196                    yLayer.visitBoundingBox(bbox);
    196                     Main.map.mapView.zoomTo(bbox);
     197                    MainApplication.getMap().mapView.zoomTo(bbox);
    197198                }
    198199
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java

    r12620 r12630  
    4747import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    4848import org.openstreetmap.josm.gui.ExtendedDialog;
     49import org.openstreetmap.josm.gui.MainApplication;
    4950import org.openstreetmap.josm.gui.MapFrame;
    5051import org.openstreetmap.josm.gui.MapFrame.MapModeChangeListener;
     
    458459
    459460    private static Dimension scaledDimension(Image thumb) {
    460         final double d = Main.map.mapView.getDist100Pixel();
     461        final double d = MainApplication.getMap().mapView.getDist100Pixel();
    461462        final double size = 10 /*meter*/;     /* size of the photo on the map */
    462463        double s = size * 100 /*px*/ / d;
     
    778779            ImageEntry img = data.get(idx);
    779780            if (img.getPos() != null) {
    780                 Point imgCenter = Main.map.mapView.getPoint(img.getPos());
     781                Point imgCenter = MainApplication.getMap().mapView.getPoint(img.getPos());
    781782                Rectangle imgRect;
    782783                if (useThumbs && img.hasThumbnail()) {
     
    932933        mouseAdapter = new MouseAdapter() {
    933934            private boolean isMapModeOk() {
    934                 return Main.map.mapMode == null || isSupportedMapMode(Main.map.mapMode);
     935                MapMode mapMode = MainApplication.getMap().mapMode;
     936                return mapMode == null || isSupportedMapMode(mapMode);
    935937            }
    936938
     
    977979
    978980        mapModeListener = (oldMapMode, newMapMode) -> {
     981            MapView mapView = MainApplication.getMap().mapView;
    979982            if (newMapMode == null || isSupportedMapMode(newMapMode)) {
    980                 Main.map.mapView.addMouseListener(mouseAdapter);
    981                 Main.map.mapView.addMouseMotionListener(mouseMotionAdapter);
     983                mapView.addMouseListener(mouseAdapter);
     984                mapView.addMouseMotionListener(mouseMotionAdapter);
    982985            } else {
    983                 Main.map.mapView.removeMouseListener(mouseAdapter);
    984                 Main.map.mapView.removeMouseMotionListener(mouseMotionAdapter);
     986                mapView.removeMouseListener(mouseAdapter);
     987                mapView.removeMouseMotionListener(mouseMotionAdapter);
    985988            }
    986989        };
    987990
    988991        MapFrame.addMapModeChangeListener(mapModeListener);
    989         mapModeListener.mapModeChange(null, Main.map.mapMode);
     992        mapModeListener.mapModeChange(null, MainApplication.getMap().mapMode);
    990993
    991994        Main.getLayerManager().addActiveLayerChangeListener(e -> {
    992995            if (Main.getLayerManager().getActiveLayer() == this) {
    993996                // only in select mode it is possible to click the images
    994                 Main.map.selectSelectTool(false);
     997                MainApplication.getMap().selectSelectTool(false);
    995998            }
    996999        });
     
    10061009                if (e.getRemovedLayer() == GeoImageLayer.this) {
    10071010                    stopLoadThumbs();
    1008                     Main.map.mapView.removeMouseListener(mouseAdapter);
    1009                     Main.map.mapView.removeMouseMotionListener(mouseMotionAdapter);
     1011                    MapView mapView = MainApplication.getMap().mapView;
     1012                    mapView.removeMouseListener(mouseAdapter);
     1013                    mapView.removeMouseMotionListener(mouseMotionAdapter);
    10101014                    MapFrame.removeMapModeChangeListener(mapModeListener);
    10111015                    currentPhoto = -1;
     
    10251029        });
    10261030
    1027         if (Main.map.getToggleDialog(ImageViewerDialog.class) == null) {
     1031        MapFrame map = MainApplication.getMap();
     1032        if (map.getToggleDialog(ImageViewerDialog.class) == null) {
    10281033            ImageViewerDialog.newInstance();
    1029             Main.map.addToggleDialog(ImageViewerDialog.getInstance());
     1034            map.addToggleDialog(ImageViewerDialog.getInstance());
    10301035        }
    10311036    }
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageViewerDialog.java

    r12460 r12630  
    2323
    2424import org.openstreetmap.josm.Main;
     25import org.openstreetmap.josm.gui.MainApplication;
    2526import org.openstreetmap.josm.gui.dialogs.DialogsPanel.Action;
    2627import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
     
    236237                centerView = button.isEnabled() && button.isSelected();
    237238                if (centerView && currentEntry != null && currentEntry.getPos() != null) {
    238                     Main.map.mapView.zoomTo(currentEntry.getPos());
     239                    MainApplication.getMap().mapView.zoomTo(currentEntry.getPos());
    239240                }
    240241            } else if (COMMAND_ZOOM.equals(action)) {
     
    309310            imageChanged = currentEntry != entry;
    310311
    311             if (centerView && entry != null && Main.isDisplayingMapView() && entry.getPos() != null) {
    312                 Main.map.mapView.zoomTo(entry.getPos());
     312            if (centerView && entry != null && MainApplication.isDisplayingMapView() && entry.getPos() != null) {
     313                MainApplication.getMap().mapView.zoomTo(entry.getPos());
    313314            }
    314315
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ThumbsLoader.java

    r12620 r12630  
    2121import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
    2222import org.openstreetmap.josm.data.cache.JCSCacheManager;
     23import org.openstreetmap.josm.gui.MainApplication;
    2324import org.openstreetmap.josm.tools.ExifReader;
    2425import org.openstreetmap.josm.tools.Logging;
     
    7980    public void run() {
    8081        Logging.debug("Load Thumbnails");
    81         tracker = new MediaTracker(Main.map.mapView);
     82        tracker = new MediaTracker(MainApplication.getMap().mapView);
    8283        for (ImageEntry entry : data) {
    8384            if (stop) return;
     
    8788                entry.setThumbnail(loadThumb(entry));
    8889
    89                 if (layer != null && Main.isDisplayingMapView()) {
     90                if (layer != null && MainApplication.isDisplayingMapView()) {
    9091                    layer.updateBufferAndRepaint();
    9192                }
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java

    r12279 r12630  
    3636import org.openstreetmap.josm.data.gpx.GpxTrack;
    3737import org.openstreetmap.josm.gui.ExtendedDialog;
     38import org.openstreetmap.josm.gui.MainApplication;
    3839import org.openstreetmap.josm.gui.layer.GpxLayer;
    3940import org.openstreetmap.josm.tools.GBC;
     
    279280            if (v != 1 && v != 2) {
    280281                layer.trackVisibility = Arrays.copyOf(trackVisibilityBackup, layer.trackVisibility.length);
    281                 Main.map.repaint();
     282                MainApplication.getMap().repaint();
    282283                return;
    283284            }
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/CustomizeDrawingAction.java

    r12377 r12630  
    1919
    2020import org.openstreetmap.josm.Main;
     21import org.openstreetmap.josm.gui.MainApplication;
    2122import org.openstreetmap.josm.gui.layer.GpxLayer;
    2223import org.openstreetmap.josm.gui.layer.Layer;
     
    111112            panel.savePreferences(layer.getName(), f);
    112113        }
    113         Main.map.repaint();
     114        MainApplication.getMap().repaint();
    114115    }
    115116
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java

    r12328 r12630  
    2626import org.openstreetmap.josm.data.gpx.WayPoint;
    2727import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     28import org.openstreetmap.josm.gui.MainApplication;
    2829import org.openstreetmap.josm.gui.layer.GpxLayer;
    2930import org.openstreetmap.josm.gui.layer.markerlayer.AudioMarker;
     
    115116            }
    116117            Main.getLayerManager().addLayer(ml);
    117             Main.map.repaint();
     118            MainApplication.getMap().repaint();
    118119        }
    119120    }
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/ReprojectionTile.java

    r12148 r12630  
    1313import org.openstreetmap.josm.data.projection.Projection;
    1414import org.openstreetmap.josm.data.projection.Projections;
     15import org.openstreetmap.josm.gui.MainApplication;
    1516import org.openstreetmap.josm.tools.ImageWarp;
    1617import org.openstreetmap.josm.tools.Utils;
     
    101102     */
    102103    protected void transform(BufferedImage imageIn) {
    103         if (!Main.isDisplayingMapView()) {
     104        if (!MainApplication.isDisplayingMapView()) {
    104105            reset();
    105106            return;
    106107        }
    107         double scaleMapView = Main.map.mapView.getScale();
     108        double scaleMapView = MainApplication.getMap().mapView.getScale();
    108109        ImageWarp.Interpolation interpolation;
    109110        switch (Main.pref.get("imagery.warp.pixel-interpolation", "bilinear")) {
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/ZoomToNativeLevelAction.java

    r12603 r12630  
    88import javax.swing.AbstractAction;
    99
    10 import org.openstreetmap.josm.Main;
     10import org.openstreetmap.josm.gui.MainApplication;
    1111import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
    1212
     
    3131    public void actionPerformed(ActionEvent ae) {
    3232        double newFactor = Math.sqrt(layer.getScaleFactor(layer.getZoomLevel()));
    33         Main.map.mapView.zoomToFactor(newFactor);
     33        MainApplication.getMap().mapView.zoomToFactor(newFactor);
    3434        layer.invalidate();
    3535    }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarker.java

    r12328 r12630  
    77import java.util.Collections;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.data.coor.LatLon;
    1110import org.openstreetmap.josm.data.gpx.GpxConstants;
    1211import org.openstreetmap.josm.data.gpx.GpxLink;
    1312import org.openstreetmap.josm.data.gpx.WayPoint;
     13import org.openstreetmap.josm.gui.MainApplication;
    1414import org.openstreetmap.josm.io.audio.AudioPlayer;
    1515import org.openstreetmap.josm.io.audio.AudioUtil;
     
    5656        try {
    5757            // first enable tracing the audio along the track
    58             Main.map.mapView.playHeadMarker.animate();
     58            MainApplication.getMap().mapView.playHeadMarker.animate();
    5959
    6060            AudioPlayer.play(audioUrl, offset + syncOffset + after);
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/ButtonMarker.java

    r10234 r12630  
    1313import org.openstreetmap.josm.Main;
    1414import org.openstreetmap.josm.data.coor.LatLon;
     15import org.openstreetmap.josm.gui.MainApplication;
    1516import org.openstreetmap.josm.gui.MapView;
    1617import org.openstreetmap.josm.tools.template_engine.TemplateEngineDataProvider;
     
    3839
    3940    @Override public boolean containsPoint(Point p) {
    40         Point screen = Main.map.mapView.getPoint(getEastNorth());
     41        Point screen = MainApplication.getMap().mapView.getPoint(getEastNorth());
    4142        buttonRectangle.setLocation(screen.x+4, screen.y+2);
    4243        return buttonRectangle.contains(p);
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

    r12620 r12630  
    3939import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    4040import org.openstreetmap.josm.data.preferences.ColorProperty;
     41import org.openstreetmap.josm.gui.MainApplication;
    4142import org.openstreetmap.josm.gui.MapView;
    4243import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
     
    351352            }
    352353        }
    353         Main.map.mapView.zoomTo(currentMarker.getEastNorth());
     354        MainApplication.getMap().mapView.zoomTo(currentMarker.getEastNorth());
    354355    }
    355356
     
    370371            }
    371372        }
    372         Main.map.mapView.zoomTo(currentMarker.getEastNorth());
     373        MainApplication.getMap().mapView.zoomTo(currentMarker.getEastNorth());
    373374    }
    374375
     
    413414
    414415    private static void playAdjacentMarker(Marker startMarker, boolean next) {
    415         if (!Main.isDisplayingMapView())
     416        if (!MainApplication.isDisplayingMapView())
    416417            return;
    417418        Marker m = null;
     
    565566                return;
    566567            }
    567             PlayHeadMarker playHeadMarker = Main.map.mapView.playHeadMarker;
     568            PlayHeadMarker playHeadMarker = MainApplication.getMap().mapView.playHeadMarker;
    568569            if (playHeadMarker == null)
    569570                return;
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java

    r12579 r12630  
    2222import org.openstreetmap.josm.data.gpx.GpxTrackSegment;
    2323import org.openstreetmap.josm.data.gpx.WayPoint;
     24import org.openstreetmap.josm.gui.MainApplication;
     25import org.openstreetmap.josm.gui.MapFrame;
    2426import org.openstreetmap.josm.gui.MapView;
    2527import org.openstreetmap.josm.gui.layer.GpxLayer;
     
    6365        if (!enabled) return;
    6466        dropTolerance = Main.pref.getInteger("marker.playHeadDropTolerance", 50);
    65         if (Main.isDisplayingMapView()) {
    66             Main.map.mapView.addMouseListener(new MouseAdapter() {
     67        if (MainApplication.isDisplayingMapView()) {
     68            MapFrame map = MainApplication.getMap();
     69            map.mapView.addMouseListener(new MouseAdapter() {
    6770                @Override public void mousePressed(MouseEvent ev) {
    6871                    if (ev.getButton() == MouseEvent.BUTTON1 && playHead.containsPoint(ev.getPoint())) {
    6972                        /* when we get a click on the marker, we need to switch mode to avoid
    7073                         * getting confused with other drag operations (like select) */
    71                         oldMode = Main.map.mapMode;
     74                        oldMode = map.mapMode;
    7275                        oldCoor = getCoor();
    7376                        PlayHeadDragMode playHeadDragMode = new PlayHeadDragMode(playHead);
    74                         Main.map.selectMapMode(playHeadDragMode);
     77                        map.selectMapMode(playHeadDragMode);
    7578                        playHeadDragMode.mousePressed(ev);
    7679                    }
     
    8285    @Override
    8386    public boolean containsPoint(Point p) {
    84         Point screen = Main.map.mapView.getPoint(getEastNorth());
     87        Point screen = MainApplication.getMap().mapView.getPoint(getEastNorth());
    8588        Rectangle r = new Rectangle(screen.x, screen.y, symbol.getIconWidth(),
    8689                symbol.getIconHeight());
     
    121124            setCoor(oldCoor);
    122125        }
    123         Main.map.selectMapMode(oldMode);
    124         Main.map.mapView.repaint();
     126        MapFrame map = MainApplication.getMap();
     127        map.selectMapMode(oldMode);
     128        map.mapView.repaint();
    125129        if (timer != null) {
    126130            timer.start();
     
    134138    public void drag(EastNorth en) {
    135139        setEastNorth(en);
    136         Main.map.mapView.repaint();
     140        MainApplication.getMap().mapView.repaint();
    137141    }
    138142
     
    148152        if (recent != null && recent.parentLayer != null && recent.parentLayer.fromLayer != null) {
    149153            /* work out EastNorth equivalent of 50 (default) pixels tolerance */
    150             Point p = Main.map.mapView.getPoint(en);
    151             EastNorth enPlus25px = Main.map.mapView.getEastNorth(p.x+dropTolerance, p.y);
     154            MapView mapView = MainApplication.getMap().mapView;
     155            Point p = mapView.getPoint(en);
     156            EastNorth enPlus25px = mapView.getEastNorth(p.x+dropTolerance, p.y);
    152157            cw = recent.parentLayer.fromLayer.data.nearestPointOnTrack(en, enPlus25px.east() - en.east());
    153158        }
     
    202207            return;
    203208        /* First, see if we dropped onto an existing audio marker in the layer being played */
    204         Point startPoint = Main.map.mapView.getPoint(en);
     209        MapView mapView = MainApplication.getMap().mapView;
     210        Point startPoint = mapView.getPoint(en);
    205211        AudioMarker ca = null;
    206212        if (recent.parentLayer != null) {
     
    225231        if (ca == null) {
    226232            /* work out EastNorth equivalent of 50 (default) pixels tolerance */
    227             Point p = Main.map.mapView.getPoint(en);
    228             EastNorth enPlus25px = Main.map.mapView.getEastNorth(p.x+dropTolerance, p.y);
     233            Point p = mapView.getPoint(en);
     234            EastNorth enPlus25px = mapView.getEastNorth(p.x+dropTolerance, p.y);
    229235            WayPoint cw = recent.parentLayer.fromLayer.data.nearestPointOnTrack(en, enPlus25px.east() - en.east());
    230236            if (cw == null) {
     
    345351                            (audioTime - w1.time)/(w2.time - w1.time)));
    346352        time = audioTime;
     353        MapView mapView = MainApplication.getMap().mapView;
    347354        if (jumpToMarker) {
    348355            jumpToMarker = false;
    349             Main.map.mapView.zoomTo(w1.getEastNorth());
    350         }
    351         Main.map.mapView.repaint();
     356            mapView.zoomTo(w1.getEastNorth());
     357        }
     358        mapView.repaint();
    352359    }
    353360}
  • trunk/src/org/openstreetmap/josm/gui/mappaint/MapPaintMenu.java

    r10453 r12630  
    1414import org.openstreetmap.josm.Main;
    1515import org.openstreetmap.josm.actions.JosmAction;
     16import org.openstreetmap.josm.gui.MainApplication;
    1617import org.openstreetmap.josm.gui.dialogs.MapPaintDialog;
    1718import org.openstreetmap.josm.gui.layer.GpxLayer;
     
    6667        @Override
    6768        public void updateEnabledState() {
    68             setEnabled(Main.isDisplayingMapView() && (Main.getLayerManager().getEditLayer() != null || mapHasGpxorMarkerLayer()));
     69            setEnabled(MainApplication.isDisplayingMapView() && (Main.getLayerManager().getEditLayer() != null || mapHasGpxorMarkerLayer()));
    6970        }
    7071
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/MapImage.java

    r12303 r12630  
    1212import javax.swing.ImageIcon;
    1313
    14 import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.gui.MainApplication;
     15import org.openstreetmap.josm.gui.MapView;
    1516import org.openstreetmap.josm.gui.mappaint.MapPaintStyles;
    1617import org.openstreetmap.josm.gui.mappaint.StyleSource;
     
    149150                        if (temporary) {
    150151                            disabledImgCache = null;
    151                             Main.map.mapView.preferenceChanged(null); // otherwise repaint is ignored, because layer hasn't changed
    152                             Main.map.mapView.repaint();
     152                            MapView mapView = MainApplication.getMap().mapView;
     153                            mapView.preferenceChanged(null); // otherwise repaint is ignored, because layer hasn't changed
     154                            mapView.repaint();
    153155                        }
    154156                        temporary = false;
  • trunk/src/org/openstreetmap/josm/gui/preferences/map/MapPaintPreference.java

    r12620 r12630  
    2020
    2121import org.openstreetmap.josm.Main;
     22import org.openstreetmap.josm.gui.MainApplication;
    2223import org.openstreetmap.josm.gui.mappaint.MapPaintStyles;
    2324import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
     
    179180            MapPaintStyles.readFromPreferences();
    180181        }
    181         if (Main.isDisplayingMapView()) {
     182        if (MainApplication.isDisplayingMapView()) {
    182183            MapPaintStyles.getStyles().clearCached();
    183184        }
  • trunk/src/org/openstreetmap/josm/gui/progress/PleaseWaitProgressMonitor.java

    r12369 r12630  
    1212
    1313import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.gui.MainApplication;
    1415import org.openstreetmap.josm.gui.MapFrame;
    1516import org.openstreetmap.josm.gui.MapStatus.BackgroundProgressMonitor;
     
    107108
    108109        BackgroundProgressMonitor backgroundMonitor = null;
    109         MapFrame map = Main.map;
     110        MapFrame map = MainApplication.getMap();
    110111        if (map != null) {
    111112            backgroundMonitor = map.statusLine.progressMonitor;
     
    314315        }
    315316        BackgroundProgressMonitor backgroundMonitor = null;
    316         MapFrame map = Main.map;
     317        MapFrame map = MainApplication.getMap();
    317318        if (map != null) {
    318319            backgroundMonitor = map.statusLine.progressMonitor;
     
    339340                dialog = null;
    340341                Main.currentProgressMonitor = null;
    341                 MapFrame map = Main.map;
     342                MapFrame map = MainApplication.getMap();
    342343                if (map != null) {
    343344                    map.statusLine.progressMonitor.setVisible(false);
     
    354355        doInEDT(() -> {
    355356            if (dialog != null) {
    356                 dialog.setInBackgroundPossible(taskId != null && Main.isDisplayingMapView());
     357                dialog.setInBackgroundPossible(taskId != null && MainApplication.isDisplayingMapView());
    357358                reset();
    358359                getDialog();
     
    366367        doInEDT(() -> {
    367368            if (dialog != null) {
    368                 dialog.setInBackgroundPossible(taskId != null && Main.isDisplayingMapView());
     369                dialog.setInBackgroundPossible(taskId != null && MainApplication.isDisplayingMapView());
    369370            }
    370371        });
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletingComboBox.java

    r12620 r12630  
    2424
    2525import org.openstreetmap.josm.Main;
     26import org.openstreetmap.josm.gui.MainApplication;
     27import org.openstreetmap.josm.gui.MapFrame;
    2628import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
    2729import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     
    5153        @Override
    5254        public void focusLost(FocusEvent e) {
    53             if (Main.map != null) {
    54                 Main.map.keyDetector.setEnabled(true);
     55            MapFrame map = MainApplication.getMap();
     56            if (map != null) {
     57                map.keyDetector.setEnabled(true);
    5558            }
    5659        }
     
    5861        @Override
    5962        public void focusGained(FocusEvent e) {
    60             if (Main.map != null) {
    61                 Main.map.keyDetector.setEnabled(false);
     63            MapFrame map = MainApplication.getMap();
     64            if (map != null) {
     65                map.keyDetector.setEnabled(false);
    6266            }
    6367            // save unix system selection (middle mouse paste)
  • trunk/src/org/openstreetmap/josm/gui/widgets/JosmPasswordField.java

    r12620 r12630  
    1313import javax.swing.text.JTextComponent;
    1414
    15 import org.openstreetmap.josm.Main;
     15import org.openstreetmap.josm.gui.MainApplication;
     16import org.openstreetmap.josm.gui.MapFrame;
    1617import org.openstreetmap.josm.tools.Logging;
    1718
     
    99100    @Override
    100101    public void focusGained(FocusEvent e) {
    101         if (Main.map != null) {
    102             Main.map.keyDetector.setEnabled(false);
     102        MapFrame map = MainApplication.getMap();
     103        if (map != null) {
     104            map.keyDetector.setEnabled(false);
    103105        }
    104106    }
     
    106108    @Override
    107109    public void focusLost(FocusEvent e) {
    108         if (Main.map != null) {
    109             Main.map.keyDetector.setEnabled(true);
     110        MapFrame map = MainApplication.getMap();
     111        if (map != null) {
     112            map.keyDetector.setEnabled(true);
    110113        }
    111114    }
  • trunk/src/org/openstreetmap/josm/gui/widgets/JosmTextArea.java

    r11308 r12630  
    99import javax.swing.text.Document;
    1010
    11 import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.gui.MainApplication;
     12import org.openstreetmap.josm.gui.MapFrame;
    1213
    1314/**
     
    105106    @Override
    106107    public void focusGained(FocusEvent e) {
    107         if (Main.map != null) {
    108             Main.map.keyDetector.setEnabled(false);
     108        MapFrame map = MainApplication.getMap();
     109        if (map != null) {
     110            map.keyDetector.setEnabled(false);
    109111        }
    110112    }
     
    112114    @Override
    113115    public void focusLost(FocusEvent e) {
    114         if (Main.map != null) {
    115             Main.map.keyDetector.setEnabled(true);
     116        MapFrame map = MainApplication.getMap();
     117        if (map != null) {
     118            map.keyDetector.setEnabled(true);
    116119        }
    117120    }
  • trunk/src/org/openstreetmap/josm/gui/widgets/JosmTextField.java

    r11809 r12630  
    1414import javax.swing.text.Document;
    1515
    16 import org.openstreetmap.josm.Main;
     16import org.openstreetmap.josm.gui.MainApplication;
     17import org.openstreetmap.josm.gui.MapFrame;
    1718
    1819/**
     
    168169    @Override
    169170    public void focusGained(FocusEvent e) {
    170         if (Main.map != null) {
    171             Main.map.keyDetector.setEnabled(false);
     171        MapFrame map = MainApplication.getMap();
     172        if (map != null) {
     173            map.keyDetector.setEnabled(false);
    172174        }
    173175        repaint();
     
    176178    @Override
    177179    public void focusLost(FocusEvent e) {
    178         if (Main.map != null) {
    179             Main.map.keyDetector.setEnabled(true);
     180        MapFrame map = MainApplication.getMap();
     181        if (map != null) {
     182            map.keyDetector.setEnabled(true);
    180183        }
    181184        repaint();
  • trunk/src/org/openstreetmap/josm/io/NoteImporter.java

    r12620 r12630  
    1212import org.openstreetmap.josm.actions.ExtensionFileFilter;
    1313import org.openstreetmap.josm.data.notes.Note;
     14import org.openstreetmap.josm.gui.MainApplication;
    1415import org.openstreetmap.josm.gui.layer.NoteLayer;
    1516import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     
    6364        final List<Note> fileNotes = new NoteReader(in).parse();
    6465        List<NoteLayer> noteLayers = null;
    65         if (Main.map != null) {
     66        if (MainApplication.getMap() != null) {
    6667            noteLayers = Main.getLayerManager().getLayersOfType(NoteLayer.class);
    6768        }
  • trunk/src/org/openstreetmap/josm/io/OsmApi.java