Changeset 5958 in josm for trunk


Ignore:
Timestamp:
2013-05-13T03:10:05+02:00 (7 years ago)
Author:
Don-vip
Message:
  • Improve PopupMenuLauncher to automatically select JTable/JList/JTree line under cursor
  • Simplify all popup menus with this new feature
  • Remove custom popup menus in BoundingBoxSelection and BoundingBoxSelection to use default text field popup menus recently introduced
  • Fix EDT violations in changeset window
  • Make Autoscale actions publicly available in MainMenu
  • Add a new "Zoom to problem" mode in AutoScaleAction
  • Make "Zoom to problem" menu item in validator dialog use this new feature
  • Update enabled state of "Zoom to Conflict" and "Zoom to problem" against selection of conflict/validator dialog
Location:
trunk
Files:
1 added
21 edited

Legend:

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

    r5460 r5958  
    1313
    1414import javax.swing.JOptionPane;
     15import javax.swing.event.ListSelectionEvent;
     16import javax.swing.event.ListSelectionListener;
     17import javax.swing.event.TreeSelectionEvent;
     18import javax.swing.event.TreeSelectionListener;
    1519
    1620import org.openstreetmap.josm.Main;
     
    1923import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2024import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     25import org.openstreetmap.josm.data.validation.TestError;
     26import org.openstreetmap.josm.gui.MapFrame;
     27import org.openstreetmap.josm.gui.MapFrameListener;
    2128import org.openstreetmap.josm.gui.MapView;
    2229import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
     30import org.openstreetmap.josm.gui.dialogs.ValidatorDialog.ValidatorBoundingXYVisitor;
    2331import org.openstreetmap.josm.gui.layer.Layer;
    2432import org.openstreetmap.josm.tools.Shortcut;
     
    3644        marktr("conflict"),
    3745        marktr("download"),
     46        marktr("problem"),
    3847        marktr("previous"),
    3948        marktr("next")};
     49   
     50    private final String mode;
     51
     52    protected ZoomChangeAdapter zoomChangeAdapter;
     53    protected MapFrameAdapter mapFrameAdapter;
    4054
    4155    /**
     
    7791    }
    7892
    79     private final String mode;
    80 
    8193    private static int getModeShortcut(String mode) {
    8294        int shortcut = -1;
     
    88100        else if (mode.equals("conflict")) { shortcut = KeyEvent.VK_4; }
    89101        else if (mode.equals("download")) { shortcut = KeyEvent.VK_5; }
     102        else if (mode.equals("problem")) { shortcut = KeyEvent.VK_6; }
    90103        else if (mode.equals("previous")) { shortcut = KeyEvent.VK_8; }
    91104        else if (mode.equals("next")) { shortcut = KeyEvent.VK_9; }
     
    95108
    96109    /**
    97      *
    98      * @param mode
     110     * Constructs a new {@code AutoScaleAction}.
     111     * @param mode The autoscale mode (one of {@link AutoScaleAction#MODES})
    99112     * @param marker Used only to differentiate from default constructor
    100113     */
     
    104117    }
    105118
    106 
    107     public AutoScaleAction(String mode) {
     119    /**
     120     * Constructs a new {@code AutoScaleAction}.
     121     * @param mode The autoscale mode (one of {@link AutoScaleAction#MODES})
     122     */
     123    public AutoScaleAction(final String mode) {
    108124        super(tr("Zoom to {0}", tr(mode)), "dialogs/autoscale/" + mode, tr("Zoom the view to {0}.", tr(mode)),
    109                 Shortcut.registerShortcut("view:zoom"+mode, tr("View: {0}", tr("Zoom to {0}", tr(mode))), getModeShortcut(mode), Shortcut.DIRECT), true);
     125                Shortcut.registerShortcut("view:zoom"+mode, tr("View: {0}", tr("Zoom to {0}", tr(mode))), getModeShortcut(mode), Shortcut.DIRECT),
     126                true, null, false);
    110127        String modeHelp = Character.toUpperCase(mode.charAt(0)) + mode.substring(1);
    111128        putValue("help", "Action/AutoScale/" + modeHelp);
     
    119136        } else if (mode.equals("conflict")) {
    120137            putValue("help", ht("/Action/ZoomToConflict"));
     138        } else if (mode.equals("problem")) {
     139            putValue("help", ht("/Action/ZoomToProblem"));
    121140        } else if (mode.equals("download")) {
    122141            putValue("help", ht("/Action/ZoomToDownload"));
     
    125144        } else if (mode.equals("next")) {
    126145            putValue("help", ht("/Action/ZoomToNext"));
    127         }
     146        } else {
     147            throw new IllegalArgumentException("Unknown mode: "+mode);
     148        }
     149        installAdapters();
    128150    }
    129151
     
    171193
    172194    private BoundingXYVisitor getBoundingBox() {
    173         BoundingXYVisitor v = new BoundingXYVisitor();
    174         if (mode.equals("data")) {
     195        BoundingXYVisitor v = mode.equals("problem") ? new ValidatorBoundingXYVisitor() : new BoundingXYVisitor();
     196
     197        if (mode.equals("problem")) {
     198            TestError error = Main.map.validatorDialog.getSelectedError();
     199            if (error == null) return null;
     200            ((ValidatorBoundingXYVisitor) v).visit(error);
     201            if (v.getBounds() == null) return null;
     202            v.enlargeBoundingBox(Main.pref.getDouble("validator.zoom-enlarge-bbox", 0.0002));
     203        } else if (mode.equals("data")) {
    175204            for (Layer l : Main.map.mapView.getAllLayers()) {
    176205                l.visitBoundingBox(v);
     
    236265                setEnabled(true);
    237266            }
     267        } else if ("conflict".equals(mode)) {
     268            setEnabled(Main.map != null && Main.map.conflictDialog.getSelectedConflict() != null);
     269        } else if ("problem".equals(mode)) {
     270            setEnabled(Main.map != null && Main.map.validatorDialog.getSelectedError() != null);
    238271        } else if ("previous".equals(mode)) {
    239272            setEnabled(Main.isDisplayingMapView() && Main.map.mapView.hasZoomUndoEntries());
     
    258291    protected void installAdapters() {
    259292        super.installAdapters();
    260         // make this action listen to zoom change events
     293        // make this action listen to zoom and mapframe change events
    261294        //
    262         zoomChangeAdapter = new ZoomChangeAdapter();
    263         MapView.addZoomChangeListener(zoomChangeAdapter);
     295        MapView.addZoomChangeListener(zoomChangeAdapter = new ZoomChangeAdapter());
     296        Main.addMapFrameListener(mapFrameAdapter = new MapFrameAdapter());
    264297        initEnabledState();
    265298    }
    266299
    267300    /**
    268      * Adapter for selection change events
    269      *
     301     * Adapter for zoom change events
    270302     */
    271303    private class ZoomChangeAdapter implements MapView.ZoomChangeListener {
     
    275307    }
    276308
    277     private ZoomChangeAdapter zoomChangeAdapter;
     309    /**
     310     * Adapter for MapFrame change events
     311     */
     312    private class MapFrameAdapter implements MapFrameListener {
     313        private ListSelectionListener conflictSelectionListener;
     314        private TreeSelectionListener validatorSelectionListener;
     315
     316        public MapFrameAdapter() {
     317            if (mode.equals("conflict")) {
     318                conflictSelectionListener = new ListSelectionListener() {
     319                    @Override public void valueChanged(ListSelectionEvent e) {
     320                        updateEnabledState();
     321                    }
     322                };
     323            } else if (mode.equals("problem")) {
     324                validatorSelectionListener = new TreeSelectionListener() {
     325                    @Override public void valueChanged(TreeSelectionEvent e) {
     326                        updateEnabledState();
     327                    }
     328                };
     329            }
     330        }
     331
     332        @Override public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame) {
     333            if (conflictSelectionListener != null) {
     334                if (newFrame != null) {
     335                    newFrame.conflictDialog.addListSelectionListener(conflictSelectionListener);
     336                } else if (oldFrame != null) {
     337                    oldFrame.conflictDialog.removeListSelectionListener(conflictSelectionListener);
     338                }
     339            } else if (validatorSelectionListener != null) {
     340                if (newFrame != null) {
     341                    newFrame.validatorDialog.addTreeSelectionListener(validatorSelectionListener);
     342                } else if (oldFrame != null) {
     343                    oldFrame.validatorDialog.removeTreeSelectionListener(validatorSelectionListener);
     344                }
     345            }
     346        }
     347    }
    278348}
  • trunk/src/org/openstreetmap/josm/gui/MainMenu.java

    r5857 r5958  
    99import java.awt.Toolkit;
    1010import java.awt.event.KeyEvent;
     11import java.util.HashMap;
     12import java.util.Map;
    1113
    1214import javax.swing.JCheckBoxMenuItem;
     
    166168    public final HistoryInfoAction historyinfo = new HistoryInfoAction();
    167169    public final HistoryInfoWebAction historyinfoweb = new HistoryInfoWebAction();
     170    public final Map<String, AutoScaleAction> autoScaleActions = new HashMap<String, AutoScaleAction>();
    168171
    169172    /* Tools menu */
     
    494497        viewMenu.addSeparator();
    495498        for (String mode : AutoScaleAction.MODES) {
    496             JosmAction autoScaleAction = new AutoScaleAction(mode);
     499            AutoScaleAction autoScaleAction = new AutoScaleAction(mode);
     500            autoScaleActions.put(mode, autoScaleAction);
    497501            add(viewMenu, autoScaleAction);
    498502        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r5360 r5958  
    107107        lstInSelection.addMouseListener(dblClickHandler);
    108108        lstInActiveDataLayer.addMouseListener(dblClickHandler);
    109 
    110         ChangesetPopupMenuLauncher popupMenuLauncher = new ChangesetPopupMenuLauncher();
    111         lstInSelection.addMouseListener(popupMenuLauncher);
    112         lstInActiveDataLayer.addMouseListener(popupMenuLauncher);
    113109    }
    114110
     
    211207        popupMenu = new ChangesetDialogPopup(lstInActiveDataLayer, lstInSelection);
    212208
     209        PopupMenuLauncher popupMenuLauncher = new PopupMenuLauncher(popupMenu);
     210        lstInSelection.addMouseListener(popupMenuLauncher);
     211        lstInActiveDataLayer.addMouseListener(popupMenuLauncher);
     212       
    213213        createLayout(pnl, false, Arrays.asList(new SideButton[] {
    214214            new SideButton(selectObjectsAction, false),
     
    522522    }
    523523
    524     class ChangesetPopupMenuLauncher extends PopupMenuLauncher {
    525         @Override
    526         public void launch(MouseEvent evt) {
    527             JList lst = getCurrentChangesetList();
    528             if (lst.getSelectedIndices().length == 0) {
    529                 int idx = lst.locationToIndex(evt.getPoint());
    530                 if (idx >=0) {
    531                     lst.getSelectionModel().addSelectionInterval(idx, idx);
    532                 }
    533             }
    534             popupMenu.show(lst, evt.getX(), evt.getY());
    535         }
    536     }
    537 
    538524    class ChangesetDialogPopup extends ListPopupMenu {
    539525        public ChangesetDialogPopup(JList ... lists) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/CommandStackDialog.java

    r5926 r5958  
    77import java.awt.Dimension;
    88import java.awt.GridBagLayout;
    9 import java.awt.Point;
    109import java.awt.event.ActionEvent;
    1110import java.awt.event.KeyEvent;
     
    8180                Shortcut.registerShortcut("subwindow:commandstack", tr("Toggle: {0}",
    8281                tr("Command Stack")), KeyEvent.VK_O, Shortcut.ALT_SHIFT), 100, true);
    83         undoTree.addMouseListener(new PopupMenuHandler());
     82        undoTree.addMouseListener(new MouseEventHandler());
    8483        undoTree.setRootVisible(false);
    8584        undoTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
     
    9190        InputMapUtils.unassignCtrlShiftUpDown(undoTree, JComponent.WHEN_FOCUSED);
    9291       
    93         redoTree.addMouseListener(new PopupMenuHandler());
     92        redoTree.addMouseListener(new MouseEventHandler());
    9493        redoTree.setRootVisible(false);
    9594        redoTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
     
    382381     * undo / redo switch to reduce duplicate code
    383382     */
    384     protected enum UndoRedoType {UNDO, REDO};
     383    protected enum UndoRedoType {UNDO, REDO}
    385384
    386385    /**
     
    444443    }
    445444
    446     class PopupMenuHandler extends PopupMenuLauncher {
     445    class MouseEventHandler extends PopupMenuLauncher {
     446
     447        public MouseEventHandler() {
     448            super(new CommandStackPopup());
     449        }
    447450       
    448451        @Override
    449452        public void mouseClicked(MouseEvent evt) {
    450             super.mouseClicked(evt);
    451             if (evt.getButton() == MouseEvent.BUTTON1 && evt.getClickCount()>1) {
     453            if (isDoubleClick(evt)) {
    452454                selectAndZoomAction.actionPerformed(null);
    453455            }
    454456        }
    455        
    456         @Override
    457         public void launch(MouseEvent evt) {
    458             Point p = evt.getPoint();
    459             JTree tree = (JTree) evt.getSource();
    460             int row = tree.getRowForLocation(p.x, p.y);
    461             if (row != -1) {
    462                 TreePath path = tree.getPathForLocation(p.x, p.y);
    463                 // right click on unselected element -> select it first
    464                 if (!tree.isPathSelected(path)) {
    465                     tree.setSelectionPath(path);
    466                 }
    467                 TreePath[] selPaths = tree.getSelectionPaths();
    468 
    469                 CommandStackPopup menu = new CommandStackPopup();
    470                 menu.show(tree, p.x, p.y-3);
    471             }
    472         }
    473     }
    474 
     457    }
    475458   
    476459    private class CommandStackPopup extends JPopupMenu {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r5775 r5958  
    1212import java.awt.event.ActionEvent;
    1313import java.awt.event.KeyEvent;
    14 import java.awt.event.MouseAdapter;
    1514import java.awt.event.MouseEvent;
    1615import java.util.Arrays;
     
    2524import javax.swing.JList;
    2625import javax.swing.JOptionPane;
     26import javax.swing.JPopupMenu;
    2727import javax.swing.ListModel;
    2828import javax.swing.ListSelectionModel;
     
    4646import org.openstreetmap.josm.data.osm.visitor.Visitor;
    4747import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     48import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
    4849import org.openstreetmap.josm.gui.MapView;
    4950import org.openstreetmap.josm.gui.NavigatableComponent;
    5051import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
     52import org.openstreetmap.josm.gui.PopupMenuHandler;
    5153import org.openstreetmap.josm.gui.SideButton;
    52 import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
    5354import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    5455import org.openstreetmap.josm.gui.util.GuiHelper;
     56import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    5557import org.openstreetmap.josm.tools.ImageProvider;
    5658import org.openstreetmap.josm.tools.Shortcut;
     
    8183    /** the list widget for the list of conflicts */
    8284    private JList lstConflicts;
     85   
     86    private final JPopupMenu popupMenu = new JPopupMenu();
     87    private final PopupMenuHandler popupMenuHandler = new PopupMenuHandler(popupMenu);
    8388
    8489    private ResolveAction actResolve;
     
    9499        lstConflicts.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
    95100        lstConflicts.setCellRenderer(new OsmPrimitivRenderer());
    96         lstConflicts.addMouseListener(new MouseAdapter(){
    97             @Override public void mouseClicked(MouseEvent e) {
    98                 if (e.getClickCount() >= 2) {
    99                     resolve();
    100                 }
    101             }
    102         });
    103         lstConflicts.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
     101        lstConflicts.addMouseListener(new MouseEventHandler());
     102        addListSelectionListener(new ListSelectionListener(){
    104103            public void valueChanged(ListSelectionEvent e) {
    105104                Main.map.mapView.repaint();
     
    108107
    109108        SideButton btnResolve = new SideButton(actResolve = new ResolveAction());
    110         lstConflicts.getSelectionModel().addListSelectionListener(actResolve);
     109        addListSelectionListener(actResolve);
    111110
    112111        SideButton btnSelect = new SideButton(actSelect = new SelectAction());
    113         lstConflicts.getSelectionModel().addListSelectionListener(actSelect);
     112        addListSelectionListener(actSelect);
    114113
    115114        createLayout(lstConflicts, true, Arrays.asList(new SideButton[] {
    116115            btnResolve, btnSelect
    117116        }));
     117       
     118        popupMenuHandler.addAction(Main.main.menu.autoScaleActions.get("conflict"));
    118119    }
    119120
     
    141142        MapView.removeEditLayerChangeListener(this);
    142143        DataSet.removeSelectionListener(this);
     144    }
     145   
     146    /**
     147     * Add a list selection listener to the conflicts list.
     148     * @param listener the ListSelectionListener
     149     * @since 5958
     150     */
     151    public void addListSelectionListener(ListSelectionListener listener) {
     152        lstConflicts.getSelectionModel().addListSelectionListener(listener);
     153    }
     154   
     155    /**
     156     * Remove the given list selection listener from the conflicts list.
     157     * @param listener the ListSelectionListener
     158     * @since 5958
     159     */
     160    public void removeListSelectionListener(ListSelectionListener listener) {
     161        lstConflicts.getSelectionModel().removeListSelectionListener(listener);
     162    }
     163   
     164    /**
     165     * Replies the popup menu handler.
     166     * @return The popup menu handler
     167     * @since 5958
     168     */
     169    public PopupMenuHandler getPopupMenuHandler() {
     170        return popupMenuHandler;
    143171    }
    144172
     
    302330    public String helpTopic() {
    303331        return ht("/Dialog/ConflictList");
     332    }
     333   
     334    class MouseEventHandler extends PopupMenuLauncher {
     335        public MouseEventHandler() {
     336            super(popupMenu);
     337        }
     338        @Override public void mouseClicked(MouseEvent e) {
     339            if (isDoubleClick(e)) {
     340                resolve();
     341            }
     342        }
    304343    }
    305344
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r5897 r5958  
    10201020
    10211021    class PopupMenuHandler extends PopupMenuLauncher {
    1022         @Override
    1023         public void launch(MouseEvent evt) {
    1024             Point p = evt.getPoint();
    1025             int index = layerList.rowAtPoint(p);
    1026             if (index < 0) return;
    1027             if (!layerList.getCellRect(index, 2, false).contains(evt.getPoint()))
    1028                 return;
    1029             if (!layerList.isRowSelected(index)) {
    1030                 layerList.setRowSelectionInterval(index, index);
    1031             }
    1032             Layer layer = model.getLayer(index);
    1033             LayerListPopup menu = new LayerListPopup(getModel().getSelectedLayers(), layer);
    1034             menu.show(layerList, p.x, p.y-3);
     1022        @Override public void launch(MouseEvent evt) {
     1023            Layer layer = getModel().getLayer(layerList.getSelectedRow());
     1024            menu = new LayerListPopup(getModel().getSelectedLayers(), layer);
     1025            super.launch(evt);
    10351026        }
    10361027    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/MapPaintDialog.java

    r5886 r5958  
    694694            if (cbWireframe.isSelected())
    695695                return;
    696             Point p = evt.getPoint();
    697             int index = tblStyles.rowAtPoint(p);
    698             if (index < 0) return;
    699             if (!tblStyles.getCellRect(index, 1, false).contains(evt.getPoint()))
    700                 return;
    701             if (!tblStyles.isRowSelected(index)) {
    702                 tblStyles.setRowSelectionInterval(index, index);
    703             }
    704             MapPaintPopup menu = new MapPaintPopup();
    705             menu.show(tblStyles, p.x, p.y);
    706         }
    707     }
    708 
     696            super.launch(evt);
     697        }
     698
     699        @Override
     700        protected void showMenu(MouseEvent evt) {
     701            menu = new MapPaintPopup();
     702            super.showMenu(evt);
     703        }
     704    }
     705
     706    /**
     707     * The popup menu displayed when right-clicking a map paint entry
     708     */
    709709    public class MapPaintPopup extends JPopupMenu {
    710710        /**
  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r5886 r5958  
    66import java.awt.BorderLayout;
    77import java.awt.Color;
    8 import java.awt.Point;
    98import java.awt.event.ActionEvent;
    109import java.awt.event.KeyEvent;
    11 import java.awt.event.MouseAdapter;
    1210import java.awt.event.MouseEvent;
    1311import java.util.ArrayList;
     
    2927import javax.swing.KeyStroke;
    3028import javax.swing.ListSelectionModel;
    31 import javax.swing.SwingUtilities;
    3229import javax.swing.UIManager;
    3330import javax.swing.event.DocumentEvent;
     
    7067import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    7168import org.openstreetmap.josm.gui.widgets.DisableShortcutsOnFocusGainedTextField;
     69import org.openstreetmap.josm.gui.widgets.JosmTextField;
     70import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    7271import org.openstreetmap.josm.tools.ImageProvider;
    7372import org.openstreetmap.josm.tools.InputMapUtils;
     
    7574import org.openstreetmap.josm.tools.Shortcut;
    7675import org.openstreetmap.josm.tools.Utils;
    77 import org.openstreetmap.josm.gui.widgets.JosmTextField;
    7876
    7977/**
     
    295293    }
    296294
    297     class MouseEventHandler extends MouseAdapter {
     295    class MouseEventHandler extends PopupMenuLauncher {
     296       
     297        public MouseEventHandler() {
     298            super(popupMenu);
     299        }
     300       
    298301        protected void setCurrentRelationAsSelection() {
    299302            Main.main.getCurrentDataSet().setSelected((Relation)displaylist.getSelectedValue());
     
    306309        @Override public void mouseClicked(MouseEvent e) {
    307310            if (Main.main.getEditLayer() == null) return;
    308             if (e.getClickCount() == 2 && SwingUtilities.isLeftMouseButton(e)) {
     311            if (isDoubleClick(e)) {
    309312                if (e.isControlDown()) {
    310313                    editCurrentRelation();
     
    312315                    setCurrentRelationAsSelection();
    313316                }
    314             }
    315         }
    316         private void openPopup(MouseEvent e) {
    317             Point p = e.getPoint();
    318             int index = displaylist.locationToIndex(p);
    319             if (index < 0) return;
    320             if (!displaylist.getCellBounds(index, index).contains(e.getPoint()))
    321                 return;
    322             if (! displaylist.isSelectedIndex(index)) {
    323                 displaylist.setSelectedIndex(index);
    324             }
    325             popupMenu.show(displaylist, p.x, p.y-3);
    326         }
    327         @Override public void mousePressed(MouseEvent e) {
    328             if (Main.main.getEditLayer() == null) return;
    329             if (e.isPopupTrigger()) {
    330                 openPopup(e);
    331             }
    332         }
    333         @Override public void mouseReleased(MouseEvent e) {
    334             if (Main.main.getEditLayer() == null) return;
    335             if (e.isPopupTrigger()) {
    336                 openPopup(e);
    337317            }
    338318        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r5903 r5958  
    1010import java.awt.event.ActionListener;
    1111import java.awt.event.KeyEvent;
    12 import java.awt.event.MouseAdapter;
    1312import java.awt.event.MouseEvent;
    1413import java.util.ArrayList;
     
    2928import javax.swing.JPopupMenu;
    3029import javax.swing.ListSelectionModel;
    31 import javax.swing.SwingUtilities;
    3230import javax.swing.event.ListDataEvent;
    3331import javax.swing.event.ListDataListener;
     
    153151        });
    154152               
    155         lstPrimitives.addMouseListener(new SelectionPopupMenuLauncher());
    156         lstPrimitives.addMouseListener(new DblClickHandler());
     153        lstPrimitives.addMouseListener(new MouseEventHandler());
    157154
    158155        InputMapUtils.addEnterAction(lstPrimitives, actZoomToListSelection);
     
    182179
    183180    /**
    184      * Responds to double clicks on the list of selected objects
    185      */
    186     class DblClickHandler extends MouseAdapter {
     181     * Responds to double clicks on the list of selected objects and launches the popup menu
     182     */
     183    class MouseEventHandler extends PopupMenuLauncher {
     184       
     185        public MouseEventHandler() {
     186            super(popupMenu);
     187        }
     188       
    187189        @Override
    188190        public void mouseClicked(MouseEvent e) {
    189             if (e.getClickCount() < 2 || ! SwingUtilities.isLeftMouseButton(e)) return;
    190             int idx = lstPrimitives.locationToIndex(e.getPoint());
    191             if (idx < 0) return;
    192             OsmDataLayer layer = Main.main.getEditLayer();
    193             if(layer == null) return;
    194             layer.data.setSelected(Collections.singleton((OsmPrimitive)model.getElementAt(idx)));
    195         }
    196     }
    197 
    198     /**
    199      * The popup menu launcher
    200      */
    201     class SelectionPopupMenuLauncher extends PopupMenuLauncher {
    202 
    203         @Override
    204         public void launch(MouseEvent evt) {
    205             if (model.getSelected().isEmpty()) {
    206                 int idx = lstPrimitives.locationToIndex(evt.getPoint());
     191            if (isDoubleClick(e)) {
     192                int idx = lstPrimitives.locationToIndex(e.getPoint());
    207193                if (idx < 0) return;
    208                 model.setSelected(Collections.singleton((OsmPrimitive)model.getElementAt(idx)));
    209             }
    210             popupMenu.show(lstPrimitives, evt.getX(), evt.getY());
     194                OsmDataLayer layer = Main.main.getEditLayer();
     195                if (layer == null) return;
     196                layer.data.setSelected(Collections.singleton((OsmPrimitive)model.getElementAt(idx)));
     197            }
    211198        }
    212199    }
     
    758745
    759746    /**
    760      * The popup menue for the JOSM selection history entries
    761      *
     747     * The popup menu for the JOSM selection history entries
    762748     */
    763749    protected static class SelectionHistoryPopup extends JPopupMenu {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r5718 r5958  
    2121import java.awt.event.ComponentAdapter;
    2222import java.awt.event.ComponentEvent;
    23 import java.awt.event.MouseAdapter;
    2423import java.awt.event.MouseEvent;
    2524import java.awt.event.WindowAdapter;
     
    4746import javax.swing.JScrollPane;
    4847import javax.swing.JToggleButton;
     48import javax.swing.SwingUtilities;
    4949
    5050import org.openstreetmap.josm.Main;
     
    6161import org.openstreetmap.josm.gui.preferences.SubPreferenceSetting;
    6262import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
     63import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    6364import org.openstreetmap.josm.tools.Destroyable;
    6465import org.openstreetmap.josm.tools.GBC;
     
    477478            add(lblTitle_weak, GBC.std().fill(GBC.HORIZONTAL));
    478479
    479             addMouseListener(
    480                     new MouseAdapter() {
    481                         @Override
    482                         public void mouseClicked(MouseEvent e) {
    483                             if (isCollapsed) {
    484                                 expand();
    485                                 dialogsPanel.reconstruct(Action.COLLAPSED_TO_DEFAULT, ToggleDialog.this);
    486                             } else {
    487                                 collapse();
    488                                 dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
    489                             }
    490                         }
    491 
    492                         private void maybeShowPopup(MouseEvent e) {
    493                             if (e.isPopupTrigger()) {
    494                                 JPopupMenu menu = new JPopupMenu();
    495                                 JMenu buttonHidingMenu = new JMenu(tr("Side buttons"));
    496                                 JRadioButtonMenuItem alwaysShown = new JRadioButtonMenuItem(new AbstractAction(tr("Always shown")) {
    497                                     @Override
    498                                     public void actionPerformed(ActionEvent e) {
    499                                         setIsButtonHiding(ButtonHiddingType.ALWAYS_SHOWN);
    500                                     }
    501                                 });
    502                                 JRadioButtonMenuItem dynamic = new JRadioButtonMenuItem(new AbstractAction(tr("Dynamic")) {
    503                                     @Override
    504                                     public void actionPerformed(ActionEvent e) {
    505                                         setIsButtonHiding(ButtonHiddingType.DYNAMIC);
    506                                     }
    507                                 });
    508                                 JRadioButtonMenuItem alwaysHidden = new JRadioButtonMenuItem(new AbstractAction(tr("Always hidden")) {
    509                                     @Override
    510                                     public void actionPerformed(ActionEvent e) {
    511                                         setIsButtonHiding(ButtonHiddingType.ALWAYS_HIDDEN);
    512                                     }
    513                                 });
    514                                 alwaysShown.setSelected(buttonHiding == ButtonHiddingType.ALWAYS_SHOWN);
    515                                 dynamic.setSelected(buttonHiding == ButtonHiddingType.DYNAMIC);
    516                                 alwaysHidden.setSelected(buttonHiding == ButtonHiddingType.ALWAYS_HIDDEN);
    517                                 buttonHidingMenu.add(alwaysShown);
    518                                 buttonHidingMenu.add(dynamic);
    519                                 buttonHidingMenu.add(alwaysHidden);
    520                                 menu.add(buttonHidingMenu);
    521                                 for (javax.swing.Action action: buttonActions) {
    522                                     menu.add(action);
    523                                 }
    524                                 menu.show(TitleBar.this, e.getX(), e.getY());
    525                             }
    526                         }
    527 
    528                         @Override
    529                         public void mousePressed(MouseEvent e) {
    530                             maybeShowPopup(e);
    531                         }
    532 
    533                         @Override
    534                         public void mouseReleased(MouseEvent e) {
    535                             maybeShowPopup(e);
    536                         }
    537                     }
    538                     );
     480            addMouseListener(new MouseEventHandler());
    539481
    540482            if(Main.pref.getBoolean("dialog.dynamic.buttons", true)) {
     
    616558            return lblTitle.getText();
    617559        }
     560       
     561        public class DialogPopupMenu extends JPopupMenu {
     562            public final JMenu buttonHidingMenu = new JMenu(tr("Side buttons"));
     563            public final JRadioButtonMenuItem alwaysShown = new JRadioButtonMenuItem(new AbstractAction(tr("Always shown")) {
     564                @Override public void actionPerformed(ActionEvent e) {
     565                    setIsButtonHiding(ButtonHiddingType.ALWAYS_SHOWN);
     566                }
     567            });
     568            public final JRadioButtonMenuItem dynamic = new JRadioButtonMenuItem(new AbstractAction(tr("Dynamic")) {
     569                @Override public void actionPerformed(ActionEvent e) {
     570                    setIsButtonHiding(ButtonHiddingType.DYNAMIC);
     571                }
     572            });
     573            public final JRadioButtonMenuItem alwaysHidden = new JRadioButtonMenuItem(new AbstractAction(tr("Always hidden")) {
     574                @Override public void actionPerformed(ActionEvent e) {
     575                    setIsButtonHiding(ButtonHiddingType.ALWAYS_HIDDEN);
     576                }
     577            });
     578            public DialogPopupMenu() {
     579                alwaysShown.setSelected(buttonHiding == ButtonHiddingType.ALWAYS_SHOWN);
     580                dynamic.setSelected(buttonHiding == ButtonHiddingType.DYNAMIC);
     581                alwaysHidden.setSelected(buttonHiding == ButtonHiddingType.ALWAYS_HIDDEN);
     582                buttonHidingMenu.add(alwaysShown);
     583                buttonHidingMenu.add(dynamic);
     584                buttonHidingMenu.add(alwaysHidden);
     585                add(buttonHidingMenu);
     586                for (javax.swing.Action action: buttonActions) {
     587                    add(action);
     588                }
     589            }
     590        }
     591       
     592        class MouseEventHandler extends PopupMenuLauncher {
     593            public MouseEventHandler() {
     594                super(new DialogPopupMenu());
     595            }
     596            @Override public void mouseClicked(MouseEvent e) {
     597                if (SwingUtilities.isLeftMouseButton(e)) {
     598                    if (isCollapsed) {
     599                        expand();
     600                        dialogsPanel.reconstruct(Action.COLLAPSED_TO_DEFAULT, ToggleDialog.this);
     601                    } else {
     602                        collapse();
     603                        dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
     604                    }
     605                }
     606            }
     607        }
    618608    }
    619609
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

    r5673 r5958  
    55
    66import java.awt.event.ActionEvent;
    7 import java.awt.event.ActionListener;
    87import java.awt.event.KeyEvent;
    9 import java.awt.event.MouseAdapter;
    108import java.awt.event.MouseEvent;
    119import java.io.IOException;
     
    2119import javax.swing.AbstractAction;
    2220import javax.swing.JComponent;
    23 import javax.swing.JMenuItem;
    2421import javax.swing.JOptionPane;
    2522import javax.swing.JPopupMenu;
     
    4542import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4643import org.openstreetmap.josm.gui.PleaseWaitRunnable;
     44import org.openstreetmap.josm.gui.PopupMenuHandler;
    4745import org.openstreetmap.josm.gui.SideButton;
    4846import org.openstreetmap.josm.gui.dialogs.validator.ValidatorTreePanel;
     
    5149import org.openstreetmap.josm.gui.preferences.ValidatorPreference;
    5250import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     51import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    5352import org.openstreetmap.josm.io.OsmTransferException;
    5453import org.openstreetmap.josm.tools.ImageProvider;
     
    6564 */
    6665public class ValidatorDialog extends ToggleDialog implements SelectionChangedListener, LayerChangeListener {
    67     /** Serializable ID */
    68     private static final long serialVersionUID = 2952292777351992696L;
    6966
    7067    /** The display tree */
     
    7875    private SideButton selectButton;
    7976
    80     private JPopupMenu popupMenu;
    81     private TestError popupMenuError = null;
    82 
     77    private final JPopupMenu popupMenu = new JPopupMenu();
     78    private final PopupMenuHandler popupMenuHandler = new PopupMenuHandler(popupMenu);
     79   
    8380    /** Last selected element */
    8481    private DefaultMutableTreeNode lastSelectedNode = null;
     
    9491                        KeyEvent.VK_V, Shortcut.ALT_SHIFT), 150, false, ValidatorPreference.class);
    9592
    96         popupMenu = new JPopupMenu();
    97 
    98         JMenuItem zoomTo = new JMenuItem(tr("Zoom to problem"));
    99         zoomTo.addActionListener(new ActionListener() {
    100             @Override
    101             public void actionPerformed(ActionEvent e) {
    102                 zoomToProblem();
    103             }
    104         });
    105         popupMenu.add(zoomTo);
     93        popupMenuHandler.addAction(Main.main.menu.autoScaleActions.get("problem"));
    10694
    10795        tree = new ValidatorTreePanel();
    108         tree.addMouseListener(new ClickWatch());
    109         tree.addTreeSelectionListener(new SelectionWatch());
     96        tree.addMouseListener(new MouseEventHandler());
     97        addTreeSelectionListener(new SelectionWatch());
    11098        InputMapUtils.unassignCtrlShiftUpDown(tree, JComponent.WHEN_FOCUSED);
    11199
     
    317305    }
    318306
    319     private void showPopupMenu(MouseEvent e) {
    320         if (!e.isPopupTrigger())
    321             return;
    322         popupMenuError = null;
    323         TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
    324         if (selPath == null)
    325             return;
    326         DefaultMutableTreeNode node = (DefaultMutableTreeNode) selPath.getPathComponent(selPath.getPathCount() - 1);
    327         if (!(node.getUserObject() instanceof TestError))
    328             return;
    329         popupMenuError = (TestError) node.getUserObject();
    330         popupMenu.show(e.getComponent(), e.getX(), e.getY());
    331     }
    332 
    333     private void zoomToProblem() {
    334         if (popupMenuError == null)
    335             return;
    336         ValidatorBoundingXYVisitor bbox = new ValidatorBoundingXYVisitor();
    337         bbox.visit(popupMenuError);
    338         if (bbox.getBounds() == null)
    339             return;
    340         bbox.enlargeBoundingBox(Main.pref.getDouble("validator.zoom-enlarge-bbox", 0.0002));
    341         Main.map.mapView.recalculateCenterScale(bbox);
    342     }
    343 
    344307    /**
    345308     * Sets the selection of the map to the current selected items.
     
    447410
    448411    /**
    449      * Watches for clicks.
    450      */
    451     public class ClickWatch extends MouseAdapter {
     412     * Add a tree selection listener to the validator tree.
     413     * @param listener the TreeSelectionListener
     414     * @since 5958
     415     */
     416    public void addTreeSelectionListener(TreeSelectionListener listener) {
     417        tree.addTreeSelectionListener(listener);
     418    }
     419   
     420    /**
     421     * Remove the given tree selection listener from the validator tree.
     422     * @param listener the TreeSelectionListener
     423     * @since 5958
     424     */
     425    public void removeTreeSelectionListener(TreeSelectionListener listener) {
     426        tree.removeTreeSelectionListener(listener);
     427    }
     428   
     429    /**
     430     * Replies the popup menu handler.
     431     * @return The popup menu handler
     432     * @since 5958
     433     */
     434    public PopupMenuHandler getPopupMenuHandler() {
     435        return popupMenuHandler;
     436    }
     437   
     438    /**
     439     * Replies the currently selected error, or {@code null}.
     440     * @return The selected error, if any.
     441     * @since 5958
     442     */
     443    public TestError getSelectedError() {
     444        Object comp = tree.getLastSelectedPathComponent();
     445        if (comp instanceof DefaultMutableTreeNode) {
     446            Object object = ((DefaultMutableTreeNode)comp).getUserObject();
     447            if (object instanceof TestError) {
     448                return (TestError) object;
     449            }
     450        }
     451        return null;
     452    }
     453   
     454    /**
     455     * Watches for double clicks and launches the popup menu.
     456     */
     457    class MouseEventHandler extends PopupMenuLauncher {
     458       
     459        public MouseEventHandler() {
     460            super(popupMenu);
     461        }
     462       
    452463        @Override
    453464        public void mouseClicked(MouseEvent e) {
     
    458469            selectButton.setEnabled(false);
    459470
    460             boolean isDblClick = e.getClickCount() > 1;
     471            boolean isDblClick = isDoubleClick(e);
    461472
    462473            Collection<OsmPrimitive> sel = isDblClick ? new HashSet<OsmPrimitive>(40) : null;
     
    467478            if (isDblClick) {
    468479                Main.main.getCurrentDataSet().setSelected(sel);
    469                 if(Main.pref.getBoolean("validator.autozoom", false)) {
     480                if (Main.pref.getBoolean("validator.autozoom", false)) {
    470481                    AutoScaleAction.zoomTo(sel);
    471482                }
    472483            }
    473484        }
    474 
    475         @Override
    476         public void mousePressed(MouseEvent e) {
    477             showPopupMenu(e);
    478         }
    479 
    480         @Override
    481         public void mouseReleased(MouseEvent e) {
    482             showPopupMenu(e);
     485       
     486        @Override public void launch(MouseEvent e) {
     487            TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
     488            if (selPath == null)
     489                return;
     490            DefaultMutableTreeNode node = (DefaultMutableTreeNode) selPath.getPathComponent(selPath.getPathCount() - 1);
     491            if (!(node.getUserObject() instanceof TestError))
     492                return;
     493            super.launch(e);
    483494        }
    484495
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManager.java

    r5903 r5958  
    1010import java.awt.event.ActionEvent;
    1111import java.awt.event.KeyEvent;
    12 import java.awt.event.MouseAdapter;
    1312import java.awt.event.MouseEvent;
    1413import java.awt.event.WindowAdapter;
     
    3332import javax.swing.KeyStroke;
    3433import javax.swing.ListSelectionModel;
    35 import javax.swing.SwingUtilities;
    3634import javax.swing.event.ListSelectionEvent;
    3735import javax.swing.event.ListSelectionListener;
     
    249247                model.getSelectionModel()
    250248        );
    251         tblChangesets.addMouseListener(new ChangesetTablePopupMenuLauncher());
    252         tblChangesets.addMouseListener(new DblClickHandler());
     249        tblChangesets.addMouseListener(new MouseEventHandler());
    253250        tblChangesets.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0), "showDetails");
    254251        tblChangesets.getActionMap().put("showDetails", new ShowDetailAction());
     
    559556    }
    560557
    561     class DblClickHandler extends MouseAdapter {
     558    class MouseEventHandler extends PopupMenuLauncher {
     559       
     560        public MouseEventHandler() {
     561            super(new ChangesetTablePopupMenu());
     562        }
     563       
    562564        @Override
    563565        public void mouseClicked(MouseEvent evt) {
    564             if (! SwingUtilities.isLeftMouseButton(evt) || evt.getClickCount()<2)
    565                 return;
    566             new ShowDetailAction().showDetails();
    567         }
    568     }
    569 
    570     class ChangesetTablePopupMenuLauncher extends PopupMenuLauncher {
    571         ChangesetTablePopupMenu menu = new ChangesetTablePopupMenu();
    572         @Override
    573         public void launch(MouseEvent evt) {
    574             if (! model.hasSelectedChangesets()) {
    575                 int row = tblChangesets.rowAtPoint(evt.getPoint());
    576                 if (row >= 0) {
    577                     model.setSelectedByIdx(row);
    578                 }
    579             }
    580             menu.show(tblChangesets, evt.getPoint().x, evt.getPoint().y);
     566            if (isDoubleClick(evt)) {
     567                new ShowDetailAction().showDetails();
     568            }
    581569        }
    582570    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManagerModel.java

    r5890 r5958  
    1919import org.openstreetmap.josm.data.osm.ChangesetCacheEvent;
    2020import org.openstreetmap.josm.data.osm.ChangesetCacheListener;
     21import org.openstreetmap.josm.gui.util.GuiHelper;
    2122
    2223/**
     
    104105     */
    105106    public void setSelectedChangesets(Collection<Changeset> selected) {
    106         selectionModel.clearSelection();
     107        GuiHelper.runInEDTAndWait(new Runnable() {
     108            @Override public void run() {
     109                selectionModel.clearSelection();
     110            }
     111        });
    107112        if (selected == null || selected.isEmpty())
    108113            return;
    109114        for (Changeset cs: selected) {
    110             int idx = data.indexOf(cs);
     115            final int idx = data.indexOf(cs);
    111116            if (idx >= 0) {
    112                 selectionModel.addSelectionInterval(idx,idx);
     117                GuiHelper.runInEDTAndWait(new Runnable() {
     118                    @Override public void run() {
     119                        selectionModel.addSelectionInterval(idx,idx);
     120                    }
     121                });
    113122            }
    114123        }
    115     }
    116 
    117     /**
    118      * Selects the changeset displayed at row <code>row</code>
    119      *
    120      * @param row the row. Ignored if < 0 or >= {@link #getRowCount()}
    121      */
    122     public void setSelectedByIdx(int row) {
    123         if (row < 0 || row >= getRowCount()) return;
    124         selectionModel.setSelectionInterval(row, row);
    125124    }
    126125
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentPanel.java

    r5495 r5958  
    1010import java.awt.event.ComponentAdapter;
    1111import java.awt.event.ComponentEvent;
    12 import java.awt.event.MouseAdapter;
    13 import java.awt.event.MouseEvent;
    1412import java.beans.PropertyChangeEvent;
    1513import java.beans.PropertyChangeListener;
     
    3129import javax.swing.JTable;
    3230import javax.swing.JToolBar;
    33 import javax.swing.SwingUtilities;
    3431import javax.swing.event.ListSelectionEvent;
    3532import javax.swing.event.ListSelectionListener;
     
    5047import org.openstreetmap.josm.gui.history.HistoryLoadTask;
    5148import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     49import org.openstreetmap.josm.gui.util.GuiHelper;
     50import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    5251import org.openstreetmap.josm.tools.BugReportExceptionHandler;
    5352import org.openstreetmap.josm.tools.ImageProvider;
     
    109108                model.getSelectionModel()
    110109        );
    111         tblContent.addMouseListener(new ChangesetContentTablePopupMenuLauncher());
     110        tblContent.addMouseListener(new PopupMenuLauncher(new ChangesetContentTablePopupMenu()));
    112111        pnl.add(new JScrollPane(tblContent), BorderLayout.CENTER);
    113112        return pnl;
     
    139138    }
    140139
     140    /**
     141     * Constructs a new {@code ChangesetContentPanel}.
     142     */
    141143    public ChangesetContentPanel() {
    142144        build();
    143145    }
    144146
     147    /**
     148     * Replies the changeset content model
     149     * @return The model
     150     */
    145151    public ChangesetContentTableModel getModel() {
    146152        return model;
     
    204210    }
    205211
    206     class ChangesetContentTablePopupMenuLauncher extends MouseAdapter {
    207         ChangesetContentTablePopupMenu menu = new ChangesetContentTablePopupMenu();
    208 
    209         protected void launch(MouseEvent evt) {
    210             if (! evt.isPopupTrigger()) return;
    211             if (! model.hasSelectedPrimitives()) {
    212                 int row = tblContent.rowAtPoint(evt.getPoint());
    213                 if (row >= 0) {
    214                     model.setSelectedByIdx(row);
    215                 }
    216             }
    217             menu.show(tblContent, evt.getPoint().x, evt.getPoint().y);
    218         }
    219 
    220         @Override
    221         public void mouseClicked(MouseEvent evt) {
    222             launch(evt);
    223         }
    224 
    225         @Override
    226         public void mousePressed(MouseEvent evt) {
    227             launch(evt);
    228         }
    229 
    230         @Override
    231         public void mouseReleased(MouseEvent evt) {
    232             launch(evt);
    233         }
    234     }
    235 
    236212    class ChangesetContentTablePopupMenu extends JPopupMenu {
    237213        public ChangesetContentTablePopupMenu() {
     
    277253                    try {
    278254                        for (HistoryOsmPrimitive p : primitives) {
    279                             History h = HistoryDataSet.getInstance().getHistory(p.getPrimitiveId());
     255                            final History h = HistoryDataSet.getInstance().getHistory(p.getPrimitiveId());
    280256                            if (h == null) {
    281257                                continue;
    282258                            }
    283                             HistoryBrowserDialogManager.getInstance().show(h);
     259                            GuiHelper.runInEDT(new Runnable() {
     260                                @Override public void run() {
     261                                    HistoryBrowserDialogManager.getInstance().show(h);
     262                                }
     263                            });
    284264                        }
    285265                    } catch (final Exception e) {
    286                         SwingUtilities.invokeLater(new Runnable() {
     266                        GuiHelper.runInEDT(new Runnable() {
    287267                            public void run() {
    288268                                BugReportExceptionHandler.handleException(e);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r5854 r5958  
    395395        membershipMenu.add(helpAction);
    396396
    397         membershipTable.addMouseListener(new PopupMenuLauncher() {
     397        membershipTable.addMouseListener(new PopupMenuLauncher(membershipMenu) {
    398398            @Override
    399             public void launch(MouseEvent evt) {
    400                 Point p = evt.getPoint();
    401                 int row = membershipTable.rowAtPoint(p);
    402                 int idx[] = membershipTable.getSelectedRows();
    403                 // if nothing or one row is selected, select row under mouse instead
    404                 if (idx.length<2 && row>-1) {
    405                     membershipTable.changeSelection(row, 0, false, false);
    406                     idx = new int[]{row};
    407                 }
     399            protected int checkTableSelection(JTable table, Point p) {
     400                int row = super.checkTableSelection(table, p);
    408401                List<Relation> rels = new ArrayList<Relation>();
    409                 for (int i: idx) {
    410                     Relation r = (Relation) (membershipData.getValueAt(i, 0));
    411                     rels.add(r);
     402                for (int i: table.getSelectedRows()) {
     403                    rels.add((Relation) table.getValueAt(i, 0));
    412404                }
    413405                membershipMenuHandler.setPrimitives(rels);
    414                 membershipMenu.show(membershipTable, p.x, p.y-3);
     406                return row;
    415407            }
    416408        });
     
    430422        propertyMenu.addSeparator();
    431423        propertyMenu.add(helpAction);
    432         propertyTable.addMouseListener(new PopupMenuLauncher() {
    433             @Override
    434             public void launch(MouseEvent evt) {
    435                 Point p = evt.getPoint();
    436                 int row = propertyTable.rowAtPoint(p);
    437                 int selectedCount = propertyTable.getSelectedRowCount();
    438                 // if nothing or one row is selected, select row under mouse instead
    439                 if (selectedCount<2 && row>-1) {
    440                     propertyTable.changeSelection(row, 0, false, false);
    441                 }
    442                 if (selectedCount>=2 || row>-1) {
    443                     propertyMenu.show(propertyTable, p.x, p.y-3);
    444                 }
    445             }
    446         });
     424        propertyTable.addMouseListener(new PopupMenuLauncher(propertyMenu));
    447425    }
    448426   
  • trunk/src/org/openstreetmap/josm/gui/download/BoundingBoxSelection.java

    r5886 r5958  
    77import java.awt.Dimension;
    88import java.awt.GridBagLayout;
    9 import java.awt.Toolkit;
    10 import java.awt.datatransfer.FlavorEvent;
    11 import java.awt.datatransfer.FlavorListener;
    129import java.awt.event.ActionEvent;
    1310import java.awt.event.ActionListener;
     
    1714import java.awt.event.MouseEvent;
    1815
    19 import javax.swing.AbstractAction;
    2016import javax.swing.BorderFactory;
    2117import javax.swing.JButton;
    2218import javax.swing.JLabel;
    2319import javax.swing.JPanel;
    24 import javax.swing.JPopupMenu;
    2520import javax.swing.UIManager;
    2621import javax.swing.border.Border;
     
    3530import org.openstreetmap.josm.gui.widgets.JosmTextField;
    3631import org.openstreetmap.josm.tools.GBC;
    37 import org.openstreetmap.josm.tools.ImageProvider;
    3832import org.openstreetmap.josm.tools.OsmUrlToBounds;
    39 import org.openstreetmap.josm.tools.Utils;
    4033
    4134/**
     
    121114        dlg.add(new JLabel(tr("URL from www.openstreetmap.org (you can paste an URL here to download the area)")), GBC.eol().insets(10,5,5,0));
    122115        dlg.add(tfOsmUrl, GBC.eop().insets(10,0,5,0).fill());
    123         tfOsmUrl.addMouseListener(
    124                 new MouseAdapter() {
    125                     @Override
    126                     public void mousePressed(MouseEvent e) {
    127                         checkPopup(e);
    128                     }
    129 
    130                     @Override
    131                     public void mouseClicked(MouseEvent e) {
    132                         checkPopup(e);
    133                     }
    134 
    135                     @Override
    136                     public void mouseReleased(MouseEvent e) {
    137                         checkPopup(e);
    138                     }
    139 
    140                     private void checkPopup(MouseEvent e) {
    141                         if (e.isPopupTrigger()) {
    142                             OsmUrlPopup popup = new OsmUrlPopup();
    143                             popup.show(tfOsmUrl, e.getX(), e.getY());
    144                         }
    145                     }
    146                 }
    147         );
    148116        dlg.add(showUrl, GBC.eop().insets(10,0,5,5));
    149117        showUrl.setEditable(false);
     
    299267    }
    300268
    301     class PasteUrlAction extends AbstractAction implements FlavorListener {
    302 
    303         public PasteUrlAction() {
    304             putValue(NAME, tr("Paste"));
    305             putValue(SMALL_ICON, ImageProvider.get("paste"));
    306             putValue(SHORT_DESCRIPTION, tr("Paste URL from clipboard"));
    307             Toolkit.getDefaultToolkit().getSystemClipboard().addFlavorListener(this);
    308         }
    309 
    310         public void actionPerformed(ActionEvent e) {
    311             String content = Utils.getClipboardContent();
    312             if (content != null) {
    313                 tfOsmUrl.setText(content);
    314             }
    315         }
    316 
    317         protected void updateEnabledState() {
    318             setEnabled(Utils.getClipboardContent() != null);
    319         }
    320 
    321         public void flavorsChanged(FlavorEvent e) {
    322             updateEnabledState();
    323         }
    324     }
    325 
    326     class OsmUrlPopup extends JPopupMenu {
    327         public OsmUrlPopup() {
    328             add(new PasteUrlAction());
    329         }
    330     }
    331 
    332269    class BoundingBoxBuilder extends FocusAdapter implements ActionListener {
    333270        protected Bounds build() {
  • trunk/src/org/openstreetmap/josm/gui/history/NodeListViewer.java

    r5266 r5958  
    2929import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
    3030import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     31import org.openstreetmap.josm.gui.util.GuiHelper;
     32import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    3133import org.openstreetmap.josm.tools.ImageProvider;
    3234
     
    6668        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    6769        selectionSynchronizer.participateInSynchronizedSelection(table.getSelectionModel());
    68         table.addMouseListener(new PopupMenuLauncher(table));
     70        table.addMouseListener(new InternalPopupMenuLauncher());
    6971        table.addMouseListener(new DoubleClickAdapter(table));
    7072        return table;
     
    7981        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    8082        selectionSynchronizer.participateInSynchronizedSelection(table.getSelectionModel());
    81         table.addMouseListener(new PopupMenuLauncher(table));
     83        table.addMouseListener(new InternalPopupMenuLauncher());
    8284        table.addMouseListener(new DoubleClickAdapter(table));
    8385        return table;
     
    115117        selectionSynchronizer = new SelectionSynchronizer();
    116118
     119        popupMenu = new NodeListPopupMenu();
     120
    117121        // ---------------------------
    118122        gc.gridx = 0;
     
    135139        gc.anchor = GridBagConstraints.NORTHWEST;
    136140        add(embeddInScrollPane(buildCurrentNodeListTable()),gc);
    137 
    138         popupMenu = new NodeListPopupMenu();
    139141    }
    140142
     
    172174
    173175    static class NodeListPopupMenu extends JPopupMenu {
    174         private ZoomToNodeAction zoomToNodeAction;
    175         private ShowHistoryAction showHistoryAction;
     176        private final ZoomToNodeAction zoomToNodeAction;
     177        private final ShowHistoryAction showHistoryAction;
    176178
    177179        public NodeListPopupMenu() {
     
    262264            Runnable r = new Runnable() {
    263265                public void run() {
    264                     History h = HistoryDataSet.getInstance().getHistory(primitiveId);
     266                    final History h = HistoryDataSet.getInstance().getHistory(primitiveId);
    265267                    if (h == null)
    266268                        return;
    267                     HistoryBrowserDialogManager.getInstance().show(h);
     269                    GuiHelper.runInEDT(new Runnable() {
     270                        @Override public void run() {
     271                            HistoryBrowserDialogManager.getInstance().show(h);
     272                        }
     273                    });
    268274                }
    269275            };
     
    283289    }
    284290
    285     class PopupMenuLauncher extends MouseAdapter {
    286         private JTable table;
    287 
    288         public PopupMenuLauncher(JTable table) {
    289             this.table = table;
    290         }
    291 
    292         @Override
    293         public void mousePressed(MouseEvent e) {
    294             showPopup(e);
    295         }
    296 
    297         @Override
    298         public void mouseReleased(MouseEvent e) {
    299             showPopup(e);
    300         }
    301 
    302         private void showPopup(MouseEvent e) {
    303             if (!e.isPopupTrigger()) return;
    304             Point p = e.getPoint();
    305             int row = table.rowAtPoint(p);
    306 
    307             PrimitiveId pid = primitiveIdAtRow(table.getModel(), row);
    308             if (pid == null)
    309                 return;
    310             popupMenu.prepare(pid);
    311             popupMenu.show(e.getComponent(), e.getX(), e.getY());
     291    class InternalPopupMenuLauncher extends PopupMenuLauncher {
     292        public InternalPopupMenuLauncher() {
     293            super(popupMenu);
     294        }
     295
     296        @Override protected int checkTableSelection(JTable table, Point p) {
     297            int row = super.checkTableSelection(table, p);
     298            popupMenu.prepare(primitiveIdAtRow(table.getModel(), row));
     299            return row;
    312300        }
    313301    }
  • trunk/src/org/openstreetmap/josm/gui/history/VersionTable.java

    r5622 r5958  
    66import java.awt.Component;
    77import java.awt.Dimension;
     8import java.awt.Point;
    89import java.awt.Rectangle;
    910import java.awt.event.ActionEvent;
    1011import java.awt.event.ItemEvent;
    1112import java.awt.event.ItemListener;
    12 import java.awt.event.MouseAdapter;
    1313import java.awt.event.MouseEvent;
    1414import java.util.Observable;
     
    3030import org.openstreetmap.josm.actions.AbstractInfoAction;
    3131import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
     32import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    3233import org.openstreetmap.josm.tools.ImageProvider;
    3334
     
    8586    }
    8687
    87     protected void showPopupMenu(MouseEvent evt) {
    88         HistoryBrowserModel.VersionTableModel model = getVersionTableModel();
    89         int row = rowAtPoint(evt.getPoint());
    90         if (row > -1 && !model.isLatest(row)) {
    91             HistoryOsmPrimitive primitive = model.getPrimitive(row);
    92             popupMenu.prepare(primitive);
    93             popupMenu.show(evt.getComponent(), evt.getX(), evt.getY());
    94         }
    95     }
    96 
    97     class MouseListener extends MouseAdapter {
     88    class MouseListener extends PopupMenuLauncher {
     89        public MouseListener() {
     90            super(popupMenu);
     91        }
    9892        @Override
    9993        public void mousePressed(MouseEvent e) {
    100             if (!showPopup(e) && e.getButton() == MouseEvent.BUTTON1) {
     94            super.mousePressed(e);
     95            if (!e.isPopupTrigger() && e.getButton() == MouseEvent.BUTTON1) {
    10196                int row = rowAtPoint(e.getPoint());
    10297                int col = columnAtPoint(e.getPoint());
     
    108103        }
    109104        @Override
    110         public void mouseReleased(MouseEvent e) {
    111             showPopup(e);
    112         }
    113         private boolean showPopup(MouseEvent e) {
    114             if (e.isPopupTrigger()) {
    115                 showPopupMenu(e);
    116                 return true;
     105        protected int checkTableSelection(JTable table, Point p) {
     106            HistoryBrowserModel.VersionTableModel model = getVersionTableModel();
     107            int row = rowAtPoint(p);
     108            if (row > -1 && !model.isLatest(row)) {
     109                popupMenu.prepare(model.getPrimitive(row));
    117110            }
    118             return false;
     111            return row;
    119112        }
    120113    }
  • trunk/src/org/openstreetmap/josm/gui/widgets/BoundingBoxSelectionPanel.java

    r5886 r5958  
    88import java.awt.GridBagLayout;
    99import java.awt.Insets;
    10 import java.awt.Toolkit;
    11 import java.awt.datatransfer.FlavorEvent;
    12 import java.awt.datatransfer.FlavorListener;
    13 import java.awt.event.ActionEvent;
    14 import java.awt.event.MouseEvent;
    15 
    16 import javax.swing.AbstractAction;
     10
    1711import javax.swing.BorderFactory;
    1812import javax.swing.JLabel;
    1913import javax.swing.JPanel;
    20 import javax.swing.JPopupMenu;
    2114import javax.swing.event.DocumentEvent;
    2215import javax.swing.event.DocumentListener;
     
    2821import org.openstreetmap.josm.gui.JMultilineLabel;
    2922import org.openstreetmap.josm.tools.GBC;
    30 import org.openstreetmap.josm.tools.ImageProvider;
    3123import org.openstreetmap.josm.tools.OsmUrlToBounds;
    32 import org.openstreetmap.josm.tools.Utils;
    33 import org.openstreetmap.josm.gui.widgets.JosmTextField;
    3424
    3525/**
     
    8777        gc.insets = new Insets(3,0,0,3);
    8878        add(tfOsmUrl, gc);
    89         tfOsmUrl.addMouseListener(new PopupMenuLauncher() {
    90             @Override
    91             public void launch(MouseEvent e) {
    92                 OsmUrlPopup popup = new OsmUrlPopup();
    93                 popup.show(tfOsmUrl, e.getX(), e.getY());
    94             }
    95         });
    9679    }
    9780
     
    224207        public void removeUpdate(DocumentEvent e) { parseURL(); }
    225208    }
    226 
    227     class PasteUrlAction extends AbstractAction implements FlavorListener {
    228 
    229         public PasteUrlAction() {
    230             putValue(NAME, tr("Paste"));
    231             putValue(SMALL_ICON, ImageProvider.get("paste"));
    232             putValue(SHORT_DESCRIPTION, tr("Paste URL from clipboard"));
    233             Toolkit.getDefaultToolkit().getSystemClipboard().addFlavorListener(this);
    234         }
    235 
    236         public void actionPerformed(ActionEvent e) {
    237             String content = Utils.getClipboardContent();
    238             if (content != null) {
    239                 tfOsmUrl.setText(content);
    240             }
    241         }
    242 
    243         protected void updateEnabledState() {
    244             setEnabled(Utils.getClipboardContent() != null);
    245         }
    246 
    247         public void flavorsChanged(FlavorEvent e) {
    248             updateEnabledState();
    249         }
    250     }
    251 
    252     class OsmUrlPopup extends JPopupMenu {
    253         public OsmUrlPopup() {
    254             add(new PasteUrlAction());
    255         }
    256     }
    257209}
  • trunk/src/org/openstreetmap/josm/gui/widgets/OsmPrimitivesTable.java

    r5310 r5958  
    3737    public OsmPrimitivesTable(OsmPrimitivesTableModel dm, TableColumnModel cm, ListSelectionModel sm) {
    3838        super(dm, cm, sm);
    39         addMouseListener(new PopupListener());
     39        addMouseListener(new PopupMenuLauncher(getPopUpMenu()));
    4040        addMouseListener(new DblClickHandler());
    4141    }
     
    7676    }
    7777
    78     protected class PopupListener extends MouseAdapter {
    79         @Override
    80         public void mousePressed(MouseEvent e) {
    81             showPopup(e);
    82         }
    83 
    84         @Override
    85         public void mouseReleased(MouseEvent e) {
    86             showPopup(e);
    87         }
    88 
    89         private void showPopup(MouseEvent e) {
    90             if (e.isPopupTrigger()) {
    91                 getPopUpMenu().show(e.getComponent(), e.getX(), e.getY());
    92             }
    93         }
    94     }
    95    
    9678    protected class DblClickHandler extends MouseAdapter {
    9779
  • trunk/src/org/openstreetmap/josm/gui/widgets/PopupMenuLauncher.java

    r5887 r5958  
    33
    44import java.awt.Component;
     5import java.awt.Point;
    56import java.awt.event.FocusEvent;
    67import java.awt.event.FocusListener;
     
    89import java.awt.event.MouseEvent;
    910
     11import javax.swing.JList;
    1012import javax.swing.JPopupMenu;
     13import javax.swing.JTable;
     14import javax.swing.JTree;
     15import javax.swing.SwingUtilities;
     16import javax.swing.tree.TreePath;
    1117
    1218/**
     
    1521 */
    1622public class PopupMenuLauncher extends MouseAdapter {
    17     private final JPopupMenu menu;
     23    protected JPopupMenu menu;
    1824    private final boolean checkEnabled;
    1925
     
    4753
    4854    @Override public void mousePressed(MouseEvent e) { processEvent(e); }
    49     @Override public void mouseClicked(MouseEvent e) { processEvent(e); }
     55    @Override public void mouseClicked(MouseEvent e) {}
    5056    @Override public void mouseReleased(MouseEvent e) { processEvent(e); }
    5157   
     
    6268     */
    6369    public void launch(final MouseEvent evt) {
    64         if (menu != null) {
     70        if (evt != null) {
    6571            final Component component = evt.getComponent();
    66             if (component != null && component.isFocusable() && !component.hasFocus() && component.requestFocusInWindow()) {
    67                 component.addFocusListener(new FocusListener() {
    68                     @Override public void focusLost(FocusEvent e) {}
    69                     @Override public void focusGained(FocusEvent e) {
    70                         menu.show(component, evt.getX(), evt.getY());
    71                         component.removeFocusListener(this);
    72                     }
    73                 });
    74             } else {
    75                 menu.show(component, evt.getX(), evt.getY());
     72            if (checkSelection(component, evt.getPoint())) {
     73                checkFocusAndShowMenu(component, evt);
    7674            }
    7775        }
     76    }
     77   
     78    protected boolean checkSelection(Component component, Point p) {
     79        if (component instanceof JList) {
     80            return checkListSelection((JList) component, p) > -1;
     81        } else if (component instanceof JTable) {
     82            return checkTableSelection((JTable) component, p) > -1;
     83        } else if (component instanceof JTree) {
     84            return checkTreeSelection((JTree) component, p) != null;
     85        }
     86        return true;
     87    }
     88   
     89    protected void checkFocusAndShowMenu(final Component component, final MouseEvent evt) {
     90        if (component != null && component.isFocusable() && !component.hasFocus() && component.requestFocusInWindow()) {
     91            component.addFocusListener(new FocusListener() {
     92                @Override public void focusLost(FocusEvent e) {}
     93                @Override public void focusGained(FocusEvent e) {
     94                    showMenu(evt);
     95                    component.removeFocusListener(this);
     96                }
     97            });
     98        } else {
     99            showMenu(evt);
     100        }
     101    }
     102   
     103    protected void showMenu(MouseEvent evt) {
     104        if (menu != null && evt != null) {
     105            menu.show(evt.getComponent(), evt.getX(), evt.getY());
     106        }
     107    }
     108   
     109    protected int checkListSelection(JList list, Point p) {
     110        int idx = list.locationToIndex(p);
     111        if (idx >= 0 && idx < list.getModel().getSize() && list.getSelectedIndices().length < 2 && !list.isSelectedIndex(idx)) {
     112            list.setSelectedIndex(idx);
     113        }
     114        return idx;
     115    }
     116
     117    protected int checkTableSelection(JTable table, Point p) {
     118        int row = table.rowAtPoint(p);
     119        if (row >= 0 && row < table.getRowCount() && table.getSelectedRowCount() < 2 && table.getSelectedRow() != row) {
     120            table.getSelectionModel().setSelectionInterval(row, row);
     121        }
     122        return row;
     123    }
     124   
     125    protected TreePath checkTreeSelection(JTree tree, Point p) {
     126        TreePath path = tree.getPathForLocation(p.x, p.y);
     127        if (path != null && tree.getSelectionCount() < 2 && !tree.isPathSelected(path)) {
     128            tree.setSelectionPath(path);
     129        }
     130        return path;
     131    }
     132   
     133    protected static boolean isDoubleClick(MouseEvent e) {
     134        return e != null && SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2;
    78135    }
    79136   
Note: See TracChangeset for help on using the changeset viewer.