Ticket #12927: patch-main-add-main-frame.patch

File patch-main-add-main-frame.patch, 29.0 KB (added by michael2402, 8 years ago)

  • src/org/openstreetmap/josm/Main.java 

    diff --git a/src/org/openstreetmap/josm/Main.java b/src/org/openstreetmap/josm/Main.java
index ac883f4..19fce6a 100644
    a b import java.awt.Component;  
    88import java.awt.GridBagConstraints;
    99import java.awt.GridBagLayout;
    1010import java.awt.Window;
    11 import java.awt.event.ComponentEvent;
    12 import java.awt.event.ComponentListener;
    1311import java.awt.event.KeyEvent;
    1412import java.awt.event.WindowAdapter;
    1513import java.awt.event.WindowEvent;
    … … import java.util.logging.Logger;  
    4644import javax.swing.Action;
    4745import javax.swing.InputMap;
    4846import javax.swing.JComponent;
    49 import javax.swing.JFrame;
    5047import javax.swing.JOptionPane;
    5148import javax.swing.JPanel;
    5249import javax.swing.JTextArea;
    … … import org.openstreetmap.josm.tools.PlatformHookUnixoid;  
    120117import org.openstreetmap.josm.tools.PlatformHookWindows;
    121118import org.openstreetmap.josm.tools.Shortcut;
    122119import org.openstreetmap.josm.tools.Utils;
    123 import org.openstreetmap.josm.tools.WindowGeometry;
    124120
    125121/**
    126122 * Abstract class holding various static global variables and methods used in large parts of JOSM application.
    … … public abstract class Main {  
    562558    }
    563559
    564560    /**
    565      * Constructs new {@code Main} object. A lot of global variables are initialized here.
     561     * Constructs new {@code Main} object.
     562     * @see #initalize()
    566563     */
    567564    public Main() {
    568565        main = this;
     566    }
     567
     568    /**
     569     * Initialize the main object. A lot of global variables are initialized here.
     570     * @since xxx
     571     */
     572    public void initalize() {
    569573        isOpenjdk = System.getProperty("java.vm.name").toUpperCase(Locale.ENGLISH).indexOf("OPENJDK") != -1;
    570574        fileWatcher.start();
    571575
    … … public abstract class Main {  
    580584
    581585            @Override
    582586            public void initialize() {
    583                 contentPanePrivate.add(panel, BorderLayout.CENTER);
    584                 panel.add(gettingStarted, BorderLayout.CENTER);
    585                 menu = new MainMenu();
     587                initializeMainWindow();
    586588            }
    587589        }.call();
    588590
    … … public abstract class Main {  
    714716        }.call();
    715717    }
    716718
     719    /**
     720     * Called once at startup to initialize the main window content.
     721     * Should set {@link #menu}
     722     */
     723    protected void initializeMainWindow() {
     724        // can be implementd by subclasses
     725    }
     726
    717727    private abstract static class InitializationTask implements Callable<Void> {
    718728
    719729        private final String name;
    … … public abstract class Main {  
    936946     */
    937947    public static final JPanel panel = new JPanel(new BorderLayout());
    938948
    939     protected static volatile WindowGeometry geometry;
    940     protected static int windowState = JFrame.NORMAL;
    941 
    942949    private final CommandQueueListener redoUndoListener = new CommandQueueListener() {
    943950        @Override
    944951        public void commandChanged(final int queueSize, final int redoSize) {
    … … public abstract class Main {  
    10151022            CoordinateFormat.setCoordinateFormat(CoordinateFormat.DECIMAL_DEGREES);
    10161023        }
    10171024
    1018         geometry = WindowGeometry.mainWindow("gui.geometry",
    1019             args.containsKey(Option.GEOMETRY) ? args.get(Option.GEOMETRY).iterator().next() : null,
    1020             !args.containsKey(Option.NO_MAXIMIZE) && Main.pref.getBoolean("gui.maximized", false));
    10211025    }
    10221026
    10231027    protected static void postConstructorProcessCmdLine(Map<Option, Collection<String>> args) {
    … … public abstract class Main {  
    11061110     */
    11071111    public static boolean exitJosm(boolean exit, int exitCode) {
    11081112        if (Main.saveUnsavedModifications()) {
    1109             worker.shutdown();
    1110             ImageProvider.shutdown(false);
    1111             JCSCacheManager.shutdown();
    1112             if (geometry != null) {
    1113                 geometry.remember("gui.geometry");
    1114             }
    1115             if (map != null) {
    1116                 map.rememberToggleDialogWidth();
    1117             }
    1118             pref.put("gui.maximized", (windowState & JFrame.MAXIMIZED_BOTH) != 0);
    1119             // Remove all layers because somebody may rely on layerRemoved events (like AutosaveTask)
    1120             if (Main.isDisplayingMapView()) {
    1121                 Collection<Layer> layers = new ArrayList<>(getLayerManager().getLayers());
    1122                 for (Layer l: layers) {
    1123                     Main.main.removeLayer(l);
    1124                 }
    1125             }
    1126             try {
    1127                 pref.saveDefaults();
    1128             } catch (IOException ex) {
    1129                 Main.warn(tr("Failed to save default preferences."));
    1130             }
    1131             worker.shutdownNow();
    1132             ImageProvider.shutdown(true);
     1113            Main.main.shutdown();
    11331114
    11341115            if (exit) {
    11351116                System.exit(exitCode);
    … … public abstract class Main {  
    11391120        return false;
    11401121    }
    11411122
     1123    protected void shutdown() {
     1124        worker.shutdown();
     1125        ImageProvider.shutdown(false);
     1126        JCSCacheManager.shutdown();
     1127        if (map != null) {
     1128            map.rememberToggleDialogWidth();
     1129        }
     1130        // Remove all layers because somebody may rely on layerRemoved events (like AutosaveTask)
     1131        if (Main.isDisplayingMapView()) {
     1132            Collection<Layer> layers = new ArrayList<>(getLayerManager().getLayers());
     1133            for (Layer l: layers) {
     1134                Main.main.removeLayer(l);
     1135            }
     1136        }
     1137        try {
     1138            pref.saveDefaults();
     1139        } catch (IOException ex) {
     1140            Main.warn(tr("Failed to save default preferences."));
     1141        }
     1142        worker.shutdownNow();
     1143        ImageProvider.shutdown(true);
     1144    }
     1145
    11421146    /**
    11431147     * The type of a command line parameter, to be used in switch statements.
    11441148     * @see #paramType
    … … public abstract class Main {  
    12881292        }
    12891293    }
    12901294
    1291     private static class WindowPositionSizeListener extends WindowAdapter implements ComponentListener {
    1292         @Override
    1293         public void windowStateChanged(WindowEvent e) {
    1294             Main.windowState = e.getNewState();
    1295         }
    1296 
    1297         @Override
    1298         public void componentHidden(ComponentEvent e) {
    1299             // Do nothing
    1300         }
    1301 
    1302         @Override
    1303         public void componentMoved(ComponentEvent e) {
    1304             handleComponentEvent(e);
    1305         }
    1306 
    1307         @Override
    1308         public void componentResized(ComponentEvent e) {
    1309             handleComponentEvent(e);
    1310         }
    1311 
    1312         @Override
    1313         public void componentShown(ComponentEvent e) {
    1314             // Do nothing
    1315         }
    1316 
    1317         private static void handleComponentEvent(ComponentEvent e) {
    1318             Component c = e.getComponent();
    1319             if (c instanceof JFrame && c.isVisible()) {
    1320                 if (Main.windowState == JFrame.NORMAL) {
    1321                     Main.geometry = new WindowGeometry((JFrame) c);
    1322                 } else {
    1323                     Main.geometry.fixScreen((JFrame) c);
    1324                 }
    1325             }
    1326         }
    1327     }
    1328 
    1329     protected static void addListener() {
    1330         parent.addComponentListener(new WindowPositionSizeListener());
    1331         ((JFrame) parent).addWindowStateListener(new WindowPositionSizeListener());
    1332     }
    1333 
    13341295    /**
    13351296     * Determines if JOSM currently runs with Java 8 or later.
    13361297     * @return {@code true} if the current JVM is at least Java 8, {@code false} otherwise

  • src/org/openstreetmap/josm/gui/MainApplication.java 

    diff --git a/src/org/openstreetmap/josm/gui/MainApplication.java b/src/org/openstreetmap/josm/gui/MainApplication.java
index 400c83f..1861960 100644
    a b import static org.openstreetmap.josm.tools.I18n.tr;  
    55import static org.openstreetmap.josm.tools.I18n.trn;
    66
    77import java.awt.Dimension;
    8 import java.awt.Image;
    9 import java.awt.Toolkit;
    10 import java.awt.event.WindowAdapter;
    11 import java.awt.event.WindowEvent;
    128import java.io.File;
    139import java.io.IOException;
    1410import java.io.InputStream;
    … … import java.util.ArrayList;  
    3228import java.util.Arrays;
    3329import java.util.Collection;
    3430import java.util.EnumMap;
    35 import java.util.LinkedList;
    3631import java.util.List;
    3732import java.util.Locale;
    3833import java.util.Map;
    … … import java.util.Set;  
    4035import java.util.TreeSet;
    4136import java.util.concurrent.Callable;
    4237
    43 import javax.swing.JFrame;
    4438import javax.swing.JOptionPane;
    4539import javax.swing.RepaintManager;
    4640import javax.swing.SwingUtilities;
    … … import org.openstreetmap.josm.plugins.PluginInformation;  
    6963import org.openstreetmap.josm.tools.FontsManager;
    7064import org.openstreetmap.josm.tools.HttpClient;
    7165import org.openstreetmap.josm.tools.I18n;
    72 import org.openstreetmap.josm.tools.ImageProvider;
    7366import org.openstreetmap.josm.tools.OsmUrlToBounds;
    7467import org.openstreetmap.josm.tools.PlatformHookWindows;
    7568import org.openstreetmap.josm.tools.Utils;
     69import org.openstreetmap.josm.tools.WindowGeometry;
    7670import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    7771
    7872import gnu.getopt.Getopt;
    … … import gnu.getopt.LongOpt;  
    8579 */
    8680public class MainApplication extends Main {
    8781
     82    private MainFrame mainFrame;
     83
    8884    /**
    89      * Constructs a new {@code MainApplication}.
     85     * Constructs a new {@code MainApplication} without a window.
    9086     */
    9187    public MainApplication() {
    92        // Allow subclassing (see JOSM.java)
     88        // Allow subclassing (see JOSM.java)
     89        this(null);
    9390    }
    9491
    9592    /**
    9693     * Constructs a main frame, ready sized and operating. Does not display the frame.
    9794     * @param mainFrame The main JFrame of the application
    9895     */
    99     public MainApplication(JFrame mainFrame) {
    100         addListener();
    101         mainFrame.setContentPane(contentPanePrivate);
    102         mainFrame.setJMenuBar(menu);
    103         geometry.applySafe(mainFrame);
    104         List<Image> l = new LinkedList<>();
    105         l.add(ImageProvider.get("logo_16x16x32").getImage());
    106         l.add(ImageProvider.get("logo_16x16x8").getImage());
    107         l.add(ImageProvider.get("logo_32x32x32").getImage());
    108         l.add(ImageProvider.get("logo_32x32x8").getImage());
    109         l.add(ImageProvider.get("logo_48x48x32").getImage());
    110         l.add(ImageProvider.get("logo_48x48x8").getImage());
    111         l.add(ImageProvider.get("logo").getImage());
    112         mainFrame.setIconImages(l);
    113         mainFrame.addWindowListener(new WindowAdapter() {
    114             @Override
    115             public void windowClosing(final WindowEvent arg0) {
    116                 Main.exitJosm(true, 0);
    117             }
    118         });
    119         mainFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
     96    public MainApplication(MainFrame mainFrame) {
     97        this.mainFrame = mainFrame;
     98    }
     99
     100    @Override
     101    protected void initializeMainWindow() {
     102        if (mainFrame != null) {
     103            mainFrame.initialize();
     104
     105            menu = mainFrame.getMenu();
     106        } else {
     107            // required for running some tests.
     108            menu = new MainMenu();
     109        }
     110    }
     111
     112    @Override
     113    protected void shutdown() {
     114        mainFrame.storeState();
     115        super.shutdown();
    120116    }
    121117
    122118    /**
    … … public class MainApplication extends Main {  
    396392
    397393        I18n.setupLanguageFonts();
    398394
    399         final JFrame mainFrame = new JFrame(tr("Java OpenStreetMap Editor"));
     395        WindowGeometry geometry = WindowGeometry.mainWindow("gui.geometry",
     396                args.containsKey(Option.GEOMETRY) ? args.get(Option.GEOMETRY).iterator().next() : null,
     397                !args.containsKey(Option.NO_MAXIMIZE) && Main.pref.getBoolean("gui.maximized", false));
     398        final MainFrame mainFrame = new MainFrame(contentPanePrivate, geometry);
    400399        Main.parent = mainFrame;
    401400
    402401        if (args.containsKey(Option.LOAD_PREFERENCES)) {
    … … public class MainApplication extends Main {  
    463462
    464463        monitor.indeterminateSubTask(tr("Creating main GUI"));
    465464        final Main main = new MainApplication(mainFrame);
     465        main.initalize();
    466466
    467467        if (!skipLoadingPlugins) {
    468468            loadLatePlugins(splash, monitor, pluginsToLoad);
    … … public class MainApplication extends Main {  
    482482
    483483        boolean maximized = Main.pref.getBoolean("gui.maximized", false);
    484484        if ((!args.containsKey(Option.NO_MAXIMIZE) && maximized) || args.containsKey(Option.MAXIMIZE)) {
    485             if (Toolkit.getDefaultToolkit().isFrameStateSupported(JFrame.MAXIMIZED_BOTH)) {
    486                 Main.windowState = JFrame.MAXIMIZED_BOTH;
    487                 mainFrame.setExtendedState(Main.windowState);
    488             } else {
    489                 Main.debug("Main window: maximizing not supported");
    490             }
     485            mainFrame.setMaximized(true);
    491486        }
    492487        if (main.menu.fullscreenToggleAction != null) {
    493488            main.menu.fullscreenToggleAction.initial();

  • new file src/org/openstreetmap/josm/gui/MainFrame.java 

    diff --git a/src/org/openstreetmap/josm/gui/MainFrame.java b/src/org/openstreetmap/josm/gui/MainFrame.java
new file mode 100644
index 0000000..9593097
    - +  
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.gui;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
     5
     6import java.awt.BorderLayout;
     7import java.awt.Component;
     8import java.awt.Container;
     9import java.awt.Image;
     10import java.awt.Rectangle;
     11import java.awt.Toolkit;
     12import java.awt.event.ComponentEvent;
     13import java.awt.event.ComponentListener;
     14import java.awt.event.WindowAdapter;
     15import java.awt.event.WindowEvent;
     16import java.beans.PropertyChangeEvent;
     17import java.beans.PropertyChangeListener;
     18import java.util.LinkedList;
     19import java.util.List;
     20
     21import javax.swing.JFrame;
     22import javax.swing.JPanel;
     23
     24import org.openstreetmap.josm.Main;
     25import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
     26import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
     27import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
     28import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
     29import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
     30import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
     31import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     32import org.openstreetmap.josm.gui.layer.OsmDataLayer.LayerStateChangeListener;
     33import org.openstreetmap.josm.tools.ImageProvider;
     34import org.openstreetmap.josm.tools.WindowGeometry;
     35
     36/**
     37 * This is the JOSM main window. It updates it's title.
     38 * @author Michael Zangl
     39 * @since xxx
     40 */
     41public class MainFrame extends JFrame {
     42    protected transient WindowGeometry geometry;
     43    protected int windowState = JFrame.NORMAL;
     44    private MainMenu menu;
     45
     46    private final transient LayerStateChangeListener updateTitleOnLayerStateChange = new LayerStateChangeListener() {
     47        @Override
     48        public void uploadDiscouragedChanged(OsmDataLayer layer, boolean newValue) {
     49            onLayerChange(layer);
     50        }
     51    };
     52
     53    private final transient PropertyChangeListener updateTitleOnSaveChange = new PropertyChangeListener() {
     54
     55        @Override
     56        public void propertyChange(PropertyChangeEvent evt) {
     57            if (evt.getPropertyName().equals(OsmDataLayer.REQUIRES_SAVE_TO_DISK_PROP)
     58                    || evt.getPropertyName().equals(OsmDataLayer.REQUIRES_UPLOAD_TO_SERVER_PROP)) {
     59                OsmDataLayer layer = (OsmDataLayer) evt.getSource();
     60                onLayerChange(layer);
     61            }
     62        }
     63    };
     64
     65    /**
     66     * Create a new main window.
     67     */
     68    public MainFrame() {
     69        this(new JPanel(), new WindowGeometry(new Rectangle(10, 10, 500, 500)));
     70    }
     71
     72    /**
     73     * Create a new main window.
     74     * @param contentPanePrivate The content
     75     * @param geometry The inital geometry to use.
     76     */
     77    public MainFrame(Container contentPanePrivate, WindowGeometry geometry) {
     78        super();
     79        this.geometry = geometry;
     80        setContentPane(contentPanePrivate);
     81    }
     82
     83    /**
     84     * Initializes the content of the window and get the current status panel.
     85     */
     86    public void initialize() {
     87        menu = new MainMenu();
     88        addComponentListener(new WindowPositionSizeListener());
     89        addWindowStateListener(new WindowPositionSizeListener());
     90
     91        setJMenuBar(menu);
     92        geometry.applySafe(this);
     93        List<Image> l = new LinkedList<>();
     94        l.add(ImageProvider.get("logo_16x16x32").getImage());
     95        l.add(ImageProvider.get("logo_16x16x8").getImage());
     96        l.add(ImageProvider.get("logo_32x32x32").getImage());
     97        l.add(ImageProvider.get("logo_32x32x8").getImage());
     98        l.add(ImageProvider.get("logo_48x48x32").getImage());
     99        l.add(ImageProvider.get("logo_48x48x8").getImage());
     100        l.add(ImageProvider.get("logo").getImage());
     101        setIconImages(l);
     102        addWindowListener(new WindowAdapter() {
     103            @Override
     104            public void windowClosing(final WindowEvent arg0) {
     105                Main.exitJosm(true, 0);
     106            }
     107        });
     108        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
     109
     110        // This listener is never removed, since the main frame exists forever.
     111        Main.getLayerManager().addActiveLayerChangeListener(new ActiveLayerChangeListener() {
     112            @Override
     113            public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
     114                refreshTitle();
     115            }
     116        }, false);
     117        Main.getLayerManager().addLayerChangeListener(new ManageLayerListeners(), true);
     118
     119        refreshTitle();
     120
     121        getContentPane().add(Main.panel, BorderLayout.CENTER);
     122        Main.panel.add(Main.main.gettingStarted, BorderLayout.CENTER);
     123        menu.initialize();
     124    }
     125
     126    /**
     127     * Stores the current state of the main frame.
     128     */
     129    public void storeState() {
     130        if (geometry != null) {
     131            geometry.remember("gui.geometry");
     132        }
     133        Main.pref.put("gui.maximized", (windowState & JFrame.MAXIMIZED_BOTH) != 0);
     134    }
     135
     136    /**
     137     * Gets the main menu used for this window.
     138     * @return The main menu.
     139     */
     140    public MainMenu getMenu() {
     141        if (menu == null) {
     142            throw new IllegalStateException("Not initialized.");
     143        }
     144        return menu;
     145    }
     146
     147    /**
     148     * Sets this frame to be maximized.
     149     * @param maximized <code>true</code> if the window should be maximized.
     150     */
     151    public void setMaximized(boolean maximized) {
     152        if (maximized) {
     153            if (Toolkit.getDefaultToolkit().isFrameStateSupported(JFrame.MAXIMIZED_BOTH)) {
     154                windowState = JFrame.MAXIMIZED_BOTH;
     155                setExtendedState(windowState);
     156            } else {
     157                Main.debug("Main window: maximizing not supported");
     158            }
     159        } else {
     160            throw new UnsupportedOperationException("Unimplemented.");
     161        }
     162    }
     163
     164    /**
     165     * Update the title of the window to reflect the current content.
     166     */
     167    public void refreshTitle() {
     168        OsmDataLayer editLayer = Main.getLayerManager().getEditLayer();
     169        boolean dirty = editLayer != null && (editLayer.requiresSaveToFile()
     170                || (editLayer.requiresUploadToServer() && !editLayer.isUploadDiscouraged()));
     171        setTitle((dirty ? "* " : "") + tr("Java OpenStreetMap Editor"));
     172        getRootPane().putClientProperty("Window.documentModified", dirty);
     173    }
     174
     175    private void onLayerChange(OsmDataLayer layer) {
     176        if (layer == Main.getLayerManager().getEditLayer()) {
     177            refreshTitle();
     178        }
     179    }
     180
     181    /**
     182     * Manages the layer listeners, adds them to every layer.
     183     */
     184    private final class ManageLayerListeners implements LayerChangeListener {
     185        @Override
     186        public void layerAdded(LayerAddEvent e) {
     187            if (e.getAddedLayer() instanceof OsmDataLayer) {
     188                OsmDataLayer osmDataLayer = (OsmDataLayer) e.getAddedLayer();
     189                osmDataLayer.addLayerStateChangeListener(updateTitleOnLayerStateChange);
     190            }
     191            e.getAddedLayer().addPropertyChangeListener(updateTitleOnSaveChange);
     192        }
     193
     194        @Override
     195        public void layerRemoving(LayerRemoveEvent e) {
     196            if (e.getRemovedLayer() instanceof OsmDataLayer) {
     197                OsmDataLayer osmDataLayer = (OsmDataLayer) e.getRemovedLayer();
     198                osmDataLayer.removeLayerStateChangeListener(updateTitleOnLayerStateChange);
     199            }
     200            e.getRemovedLayer().removePropertyChangeListener(updateTitleOnSaveChange);
     201        }
     202
     203        @Override
     204        public void layerOrderChanged(LayerOrderChangeEvent e) {
     205            // not used
     206        }
     207    }
     208
     209    private class WindowPositionSizeListener extends WindowAdapter implements ComponentListener {
     210        @Override
     211        public void windowStateChanged(WindowEvent e) {
     212            windowState = e.getNewState();
     213        }
     214
     215        @Override
     216        public void componentHidden(ComponentEvent e) {
     217            // Do nothing
     218        }
     219
     220        @Override
     221        public void componentMoved(ComponentEvent e) {
     222            handleComponentEvent(e);
     223        }
     224
     225        @Override
     226        public void componentResized(ComponentEvent e) {
     227            handleComponentEvent(e);
     228        }
     229
     230        @Override
     231        public void componentShown(ComponentEvent e) {
     232            // Do nothing
     233        }
     234
     235        private void handleComponentEvent(ComponentEvent e) {
     236            Component c = e.getComponent();
     237            if (c instanceof JFrame && c.isVisible()) {
     238                if (windowState == JFrame.NORMAL) {
     239                    geometry = new WindowGeometry((JFrame) c);
     240                } else {
     241                    geometry.fixScreen((JFrame) c);
     242                }
     243            }
     244        }
     245    }
     246
     247}

  • src/org/openstreetmap/josm/gui/MainMenu.java 

    diff --git a/src/org/openstreetmap/josm/gui/MainMenu.java b/src/org/openstreetmap/josm/gui/MainMenu.java
index 15115e1..5b02ec9 100644
    a b public class MainMenu extends JMenuBar {  
    632632    }
    633633
    634634    /**
    635      * Constructs a new {@code MainMenu}.
     635     * Initialize the main menu.
    636636     */
    637     public MainMenu() {
     637    public void initialize() {
    638638        moreToolsMenu.setVisible(false);
    639639        dataMenu.setVisible(false);
    640640        gpsMenu.setVisible(false);

  • src/org/openstreetmap/josm/gui/MapView.java 

    diff --git a/src/org/openstreetmap/josm/gui/MapView.java b/src/org/openstreetmap/josm/gui/MapView.java
index d32dc94..d2859f7 100644
    a b import javax.swing.AbstractButton;  
    3434import javax.swing.ActionMap;
    3535import javax.swing.InputMap;
    3636import javax.swing.JComponent;
    37 import javax.swing.JFrame;
    3837import javax.swing.JPanel;
    3938
    4039import org.openstreetmap.josm.Main;
    … … import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;  
    9089 * @author imi
    9190 */
    9291public class MapView extends NavigatableComponent
    93 implements PropertyChangeListener, PreferenceChangedListener, OsmDataLayer.LayerStateChangeListener,
     92implements PropertyChangeListener, PreferenceChangedListener,
    9493LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {
    9594    /**
    9695     * Interface to notify listeners of a layer change.
    … … LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {  
    578577            playHeadMarker = PlayHeadMarker.create();
    579578        }
    580579
    581         boolean isOsmDataLayer = layer instanceof OsmDataLayer;
    582         if (isOsmDataLayer) {
    583             ((OsmDataLayer) layer).addLayerStateChangeListener(this);
    584         }
    585 
    586580        layer.addPropertyChangeListener(this);
    587581        Main.addProjectionChangeListener(layer);
    588582        invalidatedListener.addTo(layer);
    … … LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {  
    665659    @Override
    666660    public void layerRemoving(LayerRemoveEvent e) {
    667661        Layer layer = e.getRemovedLayer();
    668         if (layer instanceof OsmDataLayer) {
    669             ((OsmDataLayer) layer).removeLayerPropertyChangeListener(this);
    670         }
    671662
    672663        Main.removeProjectionChangeListener(layer);
    673664        layer.removePropertyChangeListener(this);
    … … LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {  
    10721063            });
    10731064        }
    10741065        AudioPlayer.reset();
    1075         refreshTitle();
    10761066        repaint();
    10771067    }
    10781068
    … … LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {  
    11551145                changedLayer = l;
    11561146                repaint();
    11571147            }
    1158         } else if (evt.getPropertyName().equals(OsmDataLayer.REQUIRES_SAVE_TO_DISK_PROP)
    1159                 || evt.getPropertyName().equals(OsmDataLayer.REQUIRES_UPLOAD_TO_SERVER_PROP)) {
    1160             OsmDataLayer layer = (OsmDataLayer) evt.getSource();
    1161             if (layer == getEditLayer()) {
    1162                 refreshTitle();
    1163             }
    11641148        }
    11651149    }
    11661150
    11671151    /**
    11681152     * Sets the title of the JOSM main window, adding a star if there are dirty layers.
    11691153     * @see Main#parent
     1154     * @deprecated Replaced by {@link MainFrame#refreshTitle()}. The {@link MainFrame} should handle this by itself.
    11701155     */
     1156    @Deprecated
    11711157    protected void refreshTitle() {
    11721158        if (Main.parent != null) {
    1173             OsmDataLayer editLayer = layerManager.getEditLayer();
    1174             boolean dirty = editLayer != null &&
    1175                     (editLayer.requiresSaveToFile() || (editLayer.requiresUploadToServer() && !editLayer.isUploadDiscouraged()));
    1176             ((JFrame) Main.parent).setTitle((dirty ? "* " : "") + tr("Java OpenStreetMap Editor"));
    1177             ((JFrame) Main.parent).getRootPane().putClientProperty("Window.documentModified", dirty);
     1159            ((MainFrame) Main.parent).refreshTitle();
    11781160        }
    11791161    }
    11801162
    … … LayerManager.LayerChangeListener, MainLayerManager.ActiveLayerChangeListener {  
    12071189        }
    12081190    }
    12091191
    1210     @Override
    1211     public void uploadDiscouragedChanged(OsmDataLayer layer, boolean newValue) {
    1212         if (layer == layerManager.getEditLayer()) {
    1213             refreshTitle();
    1214         }
    1215     }
    1216 
    12171192    /**
    12181193     * Get a string representation of all layers suitable for the {@code source} changeset tag.
    12191194     * @return A String of sources separated by ';'

  • src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java 

    diff --git a/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java b/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java
index 6cd3c50..624c16c 100644
    a b public class OsmDataLayer extends AbstractModifiableLayer implements Listener, S  
    268268    }
    269269
    270270    /**
    271      * Removes a layer property change listener
     271     * Removes a layer state change listener
    272272     *
    273273     * @param listener the listener. Ignored if null or already registered.
    274274     * @since 5519
     275     * @deprecated Method name contains a typo, use {@link #removeLayerStateChangeListener(LayerStateChangeListener)}.
    275276     */
     277    @Deprecated
    276278    public void removeLayerPropertyChangeListener(LayerStateChangeListener listener) {
     279        removeLayerStateChangeListener(listener);
     280    }
     281
     282    /**
     283     * Removes a layer state change listener
     284     *
     285     * @param listener the listener. Ignored if null or already registered.
     286     * @since xxx
     287     */
     288    public void removeLayerStateChangeListener(LayerStateChangeListener listener) {
    277289        layerStateChangeListeners.remove(listener);
    278290    }
    279291

  • test/unit/org/openstreetmap/josm/JOSMFixture.java 

    diff --git a/test/unit/org/openstreetmap/josm/JOSMFixture.java b/test/unit/org/openstreetmap/josm/JOSMFixture.java
index 21ec5c7..66db5e5 100644
    a b public class JOSMFixture {  
    119119                Main.toolbar = new ToolbarPreferences();
    120120            }
    121121            if (Main.main == null) {
    122                 new MainApplication();
     122                new MainApplication().initalize();
    123123            }
    124124            if (Main.map == null) {
    125125                Main.main.createMapFrame(null, null);

  • test/unit/org/openstreetmap/josm/MainTest.java 

    diff --git a/test/unit/org/openstreetmap/josm/MainTest.java b/test/unit/org/openstreetmap/josm/MainTest.java
index 3e6f015..ca80f24 100644
    a b import static org.junit.Assert.assertFalse;  
    66import static org.junit.Assert.assertNull;
    77import static org.junit.Assert.assertTrue;
    88
    9 import java.awt.Dimension;
    10 import java.awt.Point;
    119import java.util.Collection;
    1210
    1311import org.junit.BeforeClass;
    1412import org.junit.Test;
    1513import org.openstreetmap.josm.Main.DownloadParamType;
    1614import org.openstreetmap.josm.gui.MainApplication;
    17 import org.openstreetmap.josm.tools.WindowGeometry;
    1815
    1916import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
    2017
    … … public class MainTest {  
    5148    public void testPreConstructorInit() {
    5249        Main.preConstructorInit(MainApplication.buildCommandLineArgumentMap(new String[0]));
    5350        Main.preConstructorInit(MainApplication.buildCommandLineArgumentMap(new String[]{"--geometry=400x300+10+5", "--no-maximize"}));
    54         assertEquals(new WindowGeometry(new Point(10, 5), new Dimension(400, 300)), Main.geometry);
     51        //assertEquals(new WindowGeometry(new Point(10, 5), new Dimension(400, 300)), Main.geometry);
    5552    }
    5653
    5754    /**