source: josm/trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java@ 12643

Last change on this file since 12643 was 12643, checked in by Don-vip, 7 years ago

see #15182 - deprecate Main.main.menu. Replacement: gui.MainApplication.getMenu()
  • Property svn:eol-style set to native
File size: 40.9 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.dialogs.relation;
3
4import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.BorderLayout;
8import java.awt.Dimension;
9import java.awt.FlowLayout;
10import java.awt.GraphicsEnvironment;
11import java.awt.GridBagConstraints;
12import java.awt.GridBagLayout;
13import java.awt.Window;
14import java.awt.datatransfer.Clipboard;
15import java.awt.datatransfer.FlavorListener;
16import java.awt.event.ActionEvent;
17import java.awt.event.FocusAdapter;
18import java.awt.event.FocusEvent;
19import java.awt.event.InputEvent;
20import java.awt.event.KeyEvent;
21import java.awt.event.MouseAdapter;
22import java.awt.event.MouseEvent;
23import java.awt.event.WindowAdapter;
24import java.awt.event.WindowEvent;
25import java.util.ArrayList;
26import java.util.Collection;
27import java.util.Collections;
28import java.util.EnumSet;
29import java.util.HashSet;
30import java.util.List;
31import java.util.Set;
32
33import javax.swing.AbstractAction;
34import javax.swing.BorderFactory;
35import javax.swing.InputMap;
36import javax.swing.JButton;
37import javax.swing.JComponent;
38import javax.swing.JLabel;
39import javax.swing.JMenuItem;
40import javax.swing.JOptionPane;
41import javax.swing.JPanel;
42import javax.swing.JRootPane;
43import javax.swing.JScrollPane;
44import javax.swing.JSplitPane;
45import javax.swing.JTabbedPane;
46import javax.swing.JTable;
47import javax.swing.JToolBar;
48import javax.swing.KeyStroke;
49
50import org.openstreetmap.josm.Main;
51import org.openstreetmap.josm.actions.ExpertToggleAction;
52import org.openstreetmap.josm.actions.JosmAction;
53import org.openstreetmap.josm.command.ChangeCommand;
54import org.openstreetmap.josm.command.Command;
55import org.openstreetmap.josm.data.osm.OsmPrimitive;
56import org.openstreetmap.josm.data.osm.Relation;
57import org.openstreetmap.josm.data.osm.RelationMember;
58import org.openstreetmap.josm.data.osm.Tag;
59import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
60import org.openstreetmap.josm.gui.DefaultNameFormatter;
61import org.openstreetmap.josm.gui.MainApplication;
62import org.openstreetmap.josm.gui.MainMenu;
63import org.openstreetmap.josm.gui.ScrollViewport;
64import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
65import org.openstreetmap.josm.gui.dialogs.relation.actions.AddSelectedAfterSelection;
66import org.openstreetmap.josm.gui.dialogs.relation.actions.AddSelectedAtEndAction;
67import org.openstreetmap.josm.gui.dialogs.relation.actions.AddSelectedAtStartAction;
68import org.openstreetmap.josm.gui.dialogs.relation.actions.AddSelectedBeforeSelection;
69import org.openstreetmap.josm.gui.dialogs.relation.actions.ApplyAction;
70import org.openstreetmap.josm.gui.dialogs.relation.actions.CancelAction;
71import org.openstreetmap.josm.gui.dialogs.relation.actions.CopyMembersAction;
72import org.openstreetmap.josm.gui.dialogs.relation.actions.DeleteCurrentRelationAction;
73import org.openstreetmap.josm.gui.dialogs.relation.actions.DownloadIncompleteMembersAction;
74import org.openstreetmap.josm.gui.dialogs.relation.actions.DownloadSelectedIncompleteMembersAction;
75import org.openstreetmap.josm.gui.dialogs.relation.actions.DuplicateRelationAction;
76import org.openstreetmap.josm.gui.dialogs.relation.actions.EditAction;
77import org.openstreetmap.josm.gui.dialogs.relation.actions.MoveDownAction;
78import org.openstreetmap.josm.gui.dialogs.relation.actions.MoveUpAction;
79import org.openstreetmap.josm.gui.dialogs.relation.actions.OKAction;
80import org.openstreetmap.josm.gui.dialogs.relation.actions.PasteMembersAction;
81import org.openstreetmap.josm.gui.dialogs.relation.actions.RefreshAction;
82import org.openstreetmap.josm.gui.dialogs.relation.actions.RemoveAction;
83import org.openstreetmap.josm.gui.dialogs.relation.actions.RemoveSelectedAction;
84import org.openstreetmap.josm.gui.dialogs.relation.actions.ReverseAction;
85import org.openstreetmap.josm.gui.dialogs.relation.actions.SelectPrimitivesForSelectedMembersAction;
86import org.openstreetmap.josm.gui.dialogs.relation.actions.SelectedMembersForSelectionAction;
87import org.openstreetmap.josm.gui.dialogs.relation.actions.SetRoleAction;
88import org.openstreetmap.josm.gui.dialogs.relation.actions.SortAction;
89import org.openstreetmap.josm.gui.dialogs.relation.actions.SortBelowAction;
90import org.openstreetmap.josm.gui.help.ContextSensitiveHelpAction;
91import org.openstreetmap.josm.gui.help.HelpUtil;
92import org.openstreetmap.josm.gui.layer.OsmDataLayer;
93import org.openstreetmap.josm.gui.tagging.TagEditorPanel;
94import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
95import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
96import org.openstreetmap.josm.gui.tagging.presets.TaggingPreset;
97import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetHandler;
98import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetType;
99import org.openstreetmap.josm.gui.tagging.presets.TaggingPresets;
100import org.openstreetmap.josm.tools.CheckParameterUtil;
101import org.openstreetmap.josm.tools.Logging;
102import org.openstreetmap.josm.tools.Shortcut;
103import org.openstreetmap.josm.tools.Utils;
104import org.openstreetmap.josm.tools.WindowGeometry;
105
106/**
107 * This dialog is for editing relations.
108 * @since 343
109 */
110public class GenericRelationEditor extends RelationEditor {
111 /** the tag table and its model */
112 private final TagEditorPanel tagEditorPanel;
113 private final ReferringRelationsBrowser referrerBrowser;
114 private final ReferringRelationsBrowserModel referrerModel;
115
116 /** the member table and its model */
117 private final MemberTable memberTable;
118 private final MemberTableModel memberTableModel;
119
120 /** the selection table and its model */
121 private final SelectionTable selectionTable;
122 private final SelectionTableModel selectionTableModel;
123
124 private final AutoCompletingTextField tfRole;
125
126 /**
127 * the menu item in the windows menu. Required to properly hide on dialog close.
128 */
129 private JMenuItem windowMenuItem;
130 /**
131 * The toolbar with the buttons on the left
132 */
133 private final LeftButtonToolbar leftButtonToolbar;
134 /**
135 * Action for performing the {@link RefreshAction}
136 */
137 private final RefreshAction refreshAction;
138 /**
139 * Action for performing the {@link ApplyAction}
140 */
141 private final ApplyAction applyAction;
142 /**
143 * Action for performing the {@link DuplicateRelationAction}
144 */
145 private final DuplicateRelationAction duplicateAction;
146 /**
147 * Action for performing the {@link DeleteCurrentRelationAction}
148 */
149 private final DeleteCurrentRelationAction deleteAction;
150 /**
151 * Action for performing the {@link OKAction}
152 */
153 private final OKAction okAction;
154 /**
155 * Action for performing the {@link CancelAction}
156 */
157 private final CancelAction cancelAction;
158 /**
159 * A list of listeners that need to be notified on clipboard content changes.
160 */
161 private final ArrayList<FlavorListener> clipboardListeners = new ArrayList<>();
162
163 /**
164 * Creates a new relation editor for the given relation. The relation will be saved if the user
165 * selects "ok" in the editor.
166 *
167 * If no relation is given, will create an editor for a new relation.
168 *
169 * @param layer the {@link OsmDataLayer} the new or edited relation belongs to
170 * @param relation relation to edit, or null to create a new one.
171 * @param selectedMembers a collection of members which shall be selected initially
172 */
173 public GenericRelationEditor(OsmDataLayer layer, Relation relation, Collection<RelationMember> selectedMembers) {
174 super(layer, relation);
175
176 setRememberWindowGeometry(getClass().getName() + ".geometry",
177 WindowGeometry.centerInWindow(Main.parent, new Dimension(700, 650)));
178
179 final TaggingPresetHandler presetHandler = new TaggingPresetHandler() {
180
181 @Override
182 public void updateTags(List<Tag> tags) {
183 tagEditorPanel.getModel().updateTags(tags);
184 }
185
186 @Override
187 public Collection<OsmPrimitive> getSelection() {
188 Relation relation = new Relation();
189 tagEditorPanel.getModel().applyToPrimitive(relation);
190 return Collections.<OsmPrimitive>singletonList(relation);
191 }
192 };
193
194 // init the various models
195 //
196 memberTableModel = new MemberTableModel(relation, getLayer(), presetHandler);
197 memberTableModel.register();
198 selectionTableModel = new SelectionTableModel(getLayer());
199 selectionTableModel.register();
200 referrerModel = new ReferringRelationsBrowserModel(relation);
201
202 tagEditorPanel = new TagEditorPanel(relation, presetHandler);
203 populateModels(relation);
204 tagEditorPanel.getModel().ensureOneTag();
205
206 // setting up the member table
207 memberTable = new MemberTable(getLayer(), getRelation(), memberTableModel);
208 memberTable.addMouseListener(new MemberTableDblClickAdapter());
209 memberTableModel.addMemberModelListener(memberTable);
210
211 MemberRoleCellEditor ce = (MemberRoleCellEditor) memberTable.getColumnModel().getColumn(0).getCellEditor();
212 selectionTable = new SelectionTable(selectionTableModel, memberTableModel);
213 selectionTable.setRowHeight(ce.getEditor().getPreferredSize().height);
214
215 leftButtonToolbar = new LeftButtonToolbar(memberTable, memberTableModel, this);
216 tfRole = buildRoleTextField(this);
217
218 JSplitPane pane = buildSplitPane(
219 buildTagEditorPanel(tagEditorPanel),
220 buildMemberEditorPanel(memberTable, memberTableModel, selectionTable, selectionTableModel, this, leftButtonToolbar, tfRole),
221 this);
222 pane.setPreferredSize(new Dimension(100, 100));
223
224 JPanel pnl = new JPanel(new BorderLayout());
225 pnl.add(pane, BorderLayout.CENTER);
226 pnl.setBorder(BorderFactory.createRaisedBevelBorder());
227
228 getContentPane().setLayout(new BorderLayout());
229 JTabbedPane tabbedPane = new JTabbedPane();
230 tabbedPane.add(tr("Tags and Members"), pnl);
231 referrerBrowser = new ReferringRelationsBrowser(getLayer(), referrerModel);
232 tabbedPane.add(tr("Parent Relations"), referrerBrowser);
233 tabbedPane.add(tr("Child Relations"), new ChildRelationBrowser(getLayer(), relation));
234 tabbedPane.addChangeListener(e -> {
235 JTabbedPane sourceTabbedPane = (JTabbedPane) e.getSource();
236 int index = sourceTabbedPane.getSelectedIndex();
237 String title = sourceTabbedPane.getTitleAt(index);
238 if (title.equals(tr("Parent Relations"))) {
239 referrerBrowser.init();
240 }
241 });
242
243 refreshAction = new RefreshAction(memberTable, memberTableModel, tagEditorPanel.getModel(), getLayer(), this);
244 applyAction = new ApplyAction(memberTable, memberTableModel, tagEditorPanel.getModel(), getLayer(), this);
245 duplicateAction = new DuplicateRelationAction(memberTableModel, tagEditorPanel.getModel(), getLayer());
246 deleteAction = new DeleteCurrentRelationAction(getLayer(), this);
247 addPropertyChangeListener(deleteAction);
248
249 okAction = new OKAction(memberTable, memberTableModel, tagEditorPanel.getModel(), getLayer(), this, tfRole);
250 cancelAction = new CancelAction(memberTable, memberTableModel, tagEditorPanel.getModel(), getLayer(), this, tfRole);
251
252 getContentPane().add(buildToolBar(refreshAction, applyAction, duplicateAction, deleteAction), BorderLayout.NORTH);
253 getContentPane().add(tabbedPane, BorderLayout.CENTER);
254 getContentPane().add(buildOkCancelButtonPanel(okAction, cancelAction), BorderLayout.SOUTH);
255
256 setSize(findMaxDialogSize());
257
258 setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
259 addWindowListener(
260 new WindowAdapter() {
261 @Override
262 public void windowOpened(WindowEvent e) {
263 cleanSelfReferences(memberTableModel, getRelation());
264 }
265
266 @Override
267 public void windowClosing(WindowEvent e) {
268 cancel();
269 }
270 }
271 );
272 // CHECKSTYLE.OFF: LineLength
273 registerCopyPasteAction(tagEditorPanel.getPasteAction(), "PASTE_TAGS",
274 Shortcut.registerShortcut("system:pastestyle", tr("Edit: {0}", tr("Paste Tags")), KeyEvent.VK_V, Shortcut.CTRL_SHIFT).getKeyStroke(),
275 getRootPane(), memberTable, selectionTable);
276 // CHECKSTYLE.ON: LineLength
277
278 KeyStroke key = Shortcut.getPasteKeyStroke();
279 if (key != null) {
280 // handle uncommon situation, that user has no keystroke assigned to paste
281 registerCopyPasteAction(new PasteMembersAction(memberTable, getLayer(), this) {
282 @Override
283 public void actionPerformed(ActionEvent e) {
284 super.actionPerformed(e);
285 tfRole.requestFocusInWindow();
286 }
287 }, "PASTE_MEMBERS", key, getRootPane(), memberTable, selectionTable);
288 }
289 key = Shortcut.getCopyKeyStroke();
290 if (key != null) {
291 // handle uncommon situation, that user has no keystroke assigned to copy
292 registerCopyPasteAction(new CopyMembersAction(memberTableModel, getLayer(), this),
293 "COPY_MEMBERS", key, getRootPane(), memberTable, selectionTable);
294 }
295 tagEditorPanel.setNextFocusComponent(memberTable);
296 selectionTable.setFocusable(false);
297 memberTableModel.setSelectedMembers(selectedMembers);
298 HelpUtil.setHelpContext(getRootPane(), ht("/Dialog/RelationEditor"));
299 }
300
301 @Override
302 public void reloadDataFromRelation() {
303 setRelation(getRelation());
304 populateModels(getRelation());
305 refreshAction.updateEnabledState();
306 }
307
308 private void populateModels(Relation relation) {
309 if (relation != null) {
310 tagEditorPanel.getModel().initFromPrimitive(relation);
311 memberTableModel.populate(relation);
312 if (!getLayer().data.getRelations().contains(relation)) {
313 // treat it as a new relation if it doesn't exist in the data set yet.
314 setRelation(null);
315 }
316 } else {
317 tagEditorPanel.getModel().clear();
318 memberTableModel.populate(null);
319 }
320 }
321
322 /**
323 * Apply changes.
324 * @see ApplyAction
325 */
326 public void apply() {
327 applyAction.actionPerformed(null);
328 }
329
330 /**
331 * Cancel changes.
332 * @see CancelAction
333 */
334 public void cancel() {
335 cancelAction.actionPerformed(null);
336 }
337
338 /**
339 * Creates the toolbar
340 * @param refreshAction refresh action
341 * @param applyAction apply action
342 * @param duplicateAction duplicate action
343 * @param deleteAction delete action
344 *
345 * @return the toolbar
346 */
347 protected static JToolBar buildToolBar(RefreshAction refreshAction, ApplyAction applyAction,
348 DuplicateRelationAction duplicateAction, DeleteCurrentRelationAction deleteAction) {
349 JToolBar tb = new JToolBar();
350 tb.setFloatable(false);
351 tb.add(refreshAction);
352 tb.add(applyAction);
353 tb.add(duplicateAction);
354 tb.add(deleteAction);
355 return tb;
356 }
357
358 /**
359 * builds the panel with the OK and the Cancel button
360 * @param okAction OK action
361 * @param cancelAction Cancel action
362 *
363 * @return the panel with the OK and the Cancel button
364 */
365 protected static JPanel buildOkCancelButtonPanel(OKAction okAction, CancelAction cancelAction) {
366 JPanel pnl = new JPanel(new FlowLayout(FlowLayout.CENTER));
367 pnl.add(new JButton(okAction));
368 pnl.add(new JButton(cancelAction));
369 pnl.add(new JButton(new ContextSensitiveHelpAction(ht("/Dialog/RelationEditor"))));
370 return pnl;
371 }
372
373 /**
374 * builds the panel with the tag editor
375 * @param tagEditorPanel tag editor panel
376 *
377 * @return the panel with the tag editor
378 */
379 protected static JPanel buildTagEditorPanel(TagEditorPanel tagEditorPanel) {
380 JPanel pnl = new JPanel(new GridBagLayout());
381
382 GridBagConstraints gc = new GridBagConstraints();
383 gc.gridx = 0;
384 gc.gridy = 0;
385 gc.gridheight = 1;
386 gc.gridwidth = 1;
387 gc.fill = GridBagConstraints.HORIZONTAL;
388 gc.anchor = GridBagConstraints.FIRST_LINE_START;
389 gc.weightx = 1.0;
390 gc.weighty = 0.0;
391 pnl.add(new JLabel(tr("Tags")), gc);
392
393 gc.gridx = 0;
394 gc.gridy = 1;
395 gc.fill = GridBagConstraints.BOTH;
396 gc.anchor = GridBagConstraints.CENTER;
397 gc.weightx = 1.0;
398 gc.weighty = 1.0;
399 pnl.add(tagEditorPanel, gc);
400 return pnl;
401 }
402
403 /**
404 * builds the role text field
405 * @param re relation editor
406 * @return the role text field
407 */
408 protected static AutoCompletingTextField buildRoleTextField(final IRelationEditor re) {
409 final AutoCompletingTextField tfRole = new AutoCompletingTextField(10);
410 tfRole.setToolTipText(tr("Enter a role and apply it to the selected relation members"));
411 tfRole.addFocusListener(new FocusAdapter() {
412 @Override
413 public void focusGained(FocusEvent e) {
414 tfRole.selectAll();
415 }
416 });
417 tfRole.setAutoCompletionList(new AutoCompletionList());
418 tfRole.addFocusListener(
419 new FocusAdapter() {
420 @Override
421 public void focusGained(FocusEvent e) {
422 AutoCompletionList list = tfRole.getAutoCompletionList();
423 if (list != null) {
424 list.clear();
425 re.getLayer().data.getAutoCompletionManager().populateWithMemberRoles(list, re.getRelation());
426 }
427 }
428 }
429 );
430 tfRole.setText(Main.pref.get("relation.editor.generic.lastrole", ""));
431 return tfRole;
432 }
433
434 /**
435 * builds the panel for the relation member editor
436 * @param memberTable member table
437 * @param memberTableModel member table model
438 * @param selectionTable selection table
439 * @param selectionTableModel selection table model
440 * @param re relation editor
441 * @param leftButtonToolbar left button toolbar
442 * @param tfRole role text field
443 *
444 * @return the panel for the relation member editor
445 */
446 protected static JPanel buildMemberEditorPanel(final MemberTable memberTable, MemberTableModel memberTableModel,
447 SelectionTable selectionTable, SelectionTableModel selectionTableModel, IRelationEditor re,
448 LeftButtonToolbar leftButtonToolbar, final AutoCompletingTextField tfRole) {
449 final JPanel pnl = new JPanel(new GridBagLayout());
450 final JScrollPane scrollPane = new JScrollPane(memberTable);
451
452 GridBagConstraints gc = new GridBagConstraints();
453 gc.gridx = 0;
454 gc.gridy = 0;
455 gc.gridwidth = 2;
456 gc.fill = GridBagConstraints.HORIZONTAL;
457 gc.anchor = GridBagConstraints.FIRST_LINE_START;
458 gc.weightx = 1.0;
459 gc.weighty = 0.0;
460 pnl.add(new JLabel(tr("Members")), gc);
461
462 gc.gridx = 0;
463 gc.gridy = 1;
464 gc.gridheight = 2;
465 gc.gridwidth = 1;
466 gc.fill = GridBagConstraints.VERTICAL;
467 gc.anchor = GridBagConstraints.NORTHWEST;
468 gc.weightx = 0.0;
469 gc.weighty = 1.0;
470 pnl.add(new ScrollViewport(leftButtonToolbar, ScrollViewport.VERTICAL_DIRECTION), gc);
471
472 gc.gridx = 1;
473 gc.gridy = 1;
474 gc.gridheight = 1;
475 gc.fill = GridBagConstraints.BOTH;
476 gc.anchor = GridBagConstraints.CENTER;
477 gc.weightx = 0.6;
478 gc.weighty = 1.0;
479 pnl.add(scrollPane, gc);
480
481 // --- role editing
482 JPanel p3 = new JPanel(new FlowLayout(FlowLayout.LEFT));
483 p3.add(new JLabel(tr("Apply Role:")));
484 p3.add(tfRole);
485 SetRoleAction setRoleAction = new SetRoleAction(memberTable, memberTableModel, tfRole);
486 memberTableModel.getSelectionModel().addListSelectionListener(setRoleAction);
487 tfRole.getDocument().addDocumentListener(setRoleAction);
488 tfRole.addActionListener(setRoleAction);
489 memberTableModel.getSelectionModel().addListSelectionListener(
490 e -> tfRole.setEnabled(memberTable.getSelectedRowCount() > 0)
491 );
492 tfRole.setEnabled(memberTable.getSelectedRowCount() > 0);
493 JButton btnApply = new JButton(setRoleAction);
494 btnApply.setPreferredSize(new Dimension(20, 20));
495 btnApply.setText("");
496 p3.add(btnApply);
497
498 gc.gridx = 1;
499 gc.gridy = 2;
500 gc.fill = GridBagConstraints.HORIZONTAL;
501 gc.anchor = GridBagConstraints.LAST_LINE_START;
502 gc.weightx = 1.0;
503 gc.weighty = 0.0;
504 pnl.add(p3, gc);
505
506 JPanel pnl2 = new JPanel(new GridBagLayout());
507
508 gc.gridx = 0;
509 gc.gridy = 0;
510 gc.gridheight = 1;
511 gc.gridwidth = 3;
512 gc.fill = GridBagConstraints.HORIZONTAL;
513 gc.anchor = GridBagConstraints.FIRST_LINE_START;
514 gc.weightx = 1.0;
515 gc.weighty = 0.0;
516 pnl2.add(new JLabel(tr("Selection")), gc);
517
518 gc.gridx = 0;
519 gc.gridy = 1;
520 gc.gridheight = 1;
521 gc.gridwidth = 1;
522 gc.fill = GridBagConstraints.VERTICAL;
523 gc.anchor = GridBagConstraints.NORTHWEST;
524 gc.weightx = 0.0;
525 gc.weighty = 1.0;
526 pnl2.add(new ScrollViewport(buildSelectionControlButtonToolbar(memberTable, memberTableModel, selectionTableModel, re),
527 ScrollViewport.VERTICAL_DIRECTION), gc);
528
529 gc.gridx = 1;
530 gc.gridy = 1;
531 gc.weightx = 1.0;
532 gc.weighty = 1.0;
533 gc.fill = GridBagConstraints.BOTH;
534 pnl2.add(buildSelectionTablePanel(selectionTable), gc);
535
536 final JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
537 splitPane.setLeftComponent(pnl);
538 splitPane.setRightComponent(pnl2);
539 splitPane.setOneTouchExpandable(false);
540 if (re instanceof Window) {
541 ((Window) re).addWindowListener(new WindowAdapter() {
542 @Override
543 public void windowOpened(WindowEvent e) {
544 // has to be called when the window is visible, otherwise no effect
545 splitPane.setDividerLocation(0.6);
546 }
547 });
548 }
549
550 JPanel pnl3 = new JPanel(new BorderLayout());
551 pnl3.add(splitPane, BorderLayout.CENTER);
552
553 return pnl3;
554 }
555
556 /**
557 * builds the panel with the table displaying the currently selected primitives
558 * @param selectionTable selection table
559 *
560 * @return panel with current selection
561 */
562 protected static JPanel buildSelectionTablePanel(SelectionTable selectionTable) {
563 JPanel pnl = new JPanel(new BorderLayout());
564 pnl.add(new JScrollPane(selectionTable), BorderLayout.CENTER);
565 return pnl;
566 }
567
568 /**
569 * builds the {@link JSplitPane} which divides the editor in an upper and a lower half
570 * @param top top panel
571 * @param bottom bottom panel
572 * @param re relation editor
573 *
574 * @return the split panel
575 */
576 protected static JSplitPane buildSplitPane(JPanel top, JPanel bottom, IRelationEditor re) {
577 final JSplitPane pane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
578 pane.setTopComponent(top);
579 pane.setBottomComponent(bottom);
580 pane.setOneTouchExpandable(true);
581 if (re instanceof Window) {
582 ((Window) re).addWindowListener(new WindowAdapter() {
583 @Override
584 public void windowOpened(WindowEvent e) {
585 // has to be called when the window is visible, otherwise no effect
586 pane.setDividerLocation(0.3);
587 }
588 });
589 }
590 return pane;
591 }
592
593 /**
594 * The toolbar with the buttons on the left
595 */
596 static class LeftButtonToolbar extends JToolBar {
597
598 /**
599 * Button for performing the {@link org.openstreetmap.josm.gui.dialogs.relation.actions.SortBelowAction}.
600 */
601 final JButton sortBelowButton;
602
603 /**
604 * Constructs a new {@code LeftButtonToolbar}.
605 * @param memberTable member table
606 * @param memberTableModel member table model
607 * @param re relation editor
608 */
609 LeftButtonToolbar(MemberTable memberTable, MemberTableModel memberTableModel, IRelationEditor re) {
610 setOrientation(JToolBar.VERTICAL);
611 setFloatable(false);
612
613 // -- move up action
614 MoveUpAction moveUpAction = new MoveUpAction(memberTable, memberTableModel, "moveUp");
615 memberTableModel.getSelectionModel().addListSelectionListener(moveUpAction);
616 add(moveUpAction);
617
618 // -- move down action
619 MoveDownAction moveDownAction = new MoveDownAction(memberTable, memberTableModel, "moveDown");
620 memberTableModel.getSelectionModel().addListSelectionListener(moveDownAction);
621 add(moveDownAction);
622
623 addSeparator();
624
625 // -- edit action
626 EditAction editAction = new EditAction(memberTable, memberTableModel, re.getLayer());
627 memberTableModel.getSelectionModel().addListSelectionListener(editAction);
628 add(editAction);
629
630 // -- delete action
631 RemoveAction removeSelectedAction = new RemoveAction(memberTable, memberTableModel, "removeSelected");
632 memberTable.getSelectionModel().addListSelectionListener(removeSelectedAction);
633 add(removeSelectedAction);
634
635 addSeparator();
636 // -- sort action
637 SortAction sortAction = new SortAction(memberTable, memberTableModel);
638 memberTableModel.addTableModelListener(sortAction);
639 add(sortAction);
640 final SortBelowAction sortBelowAction = new SortBelowAction(memberTable, memberTableModel);
641 memberTableModel.addTableModelListener(sortBelowAction);
642 memberTableModel.getSelectionModel().addListSelectionListener(sortBelowAction);
643 sortBelowButton = add(sortBelowAction);
644
645 // -- reverse action
646 ReverseAction reverseAction = new ReverseAction(memberTable, memberTableModel);
647 memberTableModel.addTableModelListener(reverseAction);
648 add(reverseAction);
649
650 addSeparator();
651
652 // -- download action
653 DownloadIncompleteMembersAction downloadIncompleteMembersAction = new DownloadIncompleteMembersAction(
654 memberTable, memberTableModel, "downloadIncomplete", re.getLayer(), re);
655 memberTable.getModel().addTableModelListener(downloadIncompleteMembersAction);
656 add(downloadIncompleteMembersAction);
657
658 // -- download selected action
659 DownloadSelectedIncompleteMembersAction downloadSelectedIncompleteMembersAction = new DownloadSelectedIncompleteMembersAction(
660 memberTable, memberTableModel, null, re.getLayer(), re);
661 memberTable.getModel().addTableModelListener(downloadSelectedIncompleteMembersAction);
662 memberTable.getSelectionModel().addListSelectionListener(downloadSelectedIncompleteMembersAction);
663 add(downloadSelectedIncompleteMembersAction);
664
665 InputMap inputMap = memberTable.getInputMap(MemberTable.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
666 inputMap.put((KeyStroke) removeSelectedAction.getValue(AbstractAction.ACCELERATOR_KEY), "removeSelected");
667 inputMap.put((KeyStroke) moveUpAction.getValue(AbstractAction.ACCELERATOR_KEY), "moveUp");
668 inputMap.put((KeyStroke) moveDownAction.getValue(AbstractAction.ACCELERATOR_KEY), "moveDown");
669 inputMap.put((KeyStroke) downloadIncompleteMembersAction.getValue(AbstractAction.ACCELERATOR_KEY), "downloadIncomplete");
670 }
671 }
672
673 /**
674 * build the toolbar with the buttons for adding or removing the current selection
675 * @param memberTable member table
676 * @param memberTableModel member table model
677 * @param selectionTableModel selection table model
678 * @param re relation editor
679 *
680 * @return control buttons panel for selection/members
681 */
682 protected static JToolBar buildSelectionControlButtonToolbar(MemberTable memberTable,
683 MemberTableModel memberTableModel, SelectionTableModel selectionTableModel, IRelationEditor re) {
684 JToolBar tb = new JToolBar(JToolBar.VERTICAL);
685 tb.setFloatable(false);
686
687 // -- add at start action
688 AddSelectedAtStartAction addSelectionAction = new AddSelectedAtStartAction(
689 memberTableModel, selectionTableModel, re);
690 selectionTableModel.addTableModelListener(addSelectionAction);
691 tb.add(addSelectionAction);
692
693 // -- add before selected action
694 AddSelectedBeforeSelection addSelectedBeforeSelectionAction = new AddSelectedBeforeSelection(
695 memberTableModel, selectionTableModel, re);
696 selectionTableModel.addTableModelListener(addSelectedBeforeSelectionAction);
697 memberTableModel.getSelectionModel().addListSelectionListener(addSelectedBeforeSelectionAction);
698 tb.add(addSelectedBeforeSelectionAction);
699
700 // -- add after selected action
701 AddSelectedAfterSelection addSelectedAfterSelectionAction = new AddSelectedAfterSelection(
702 memberTableModel, selectionTableModel, re);
703 selectionTableModel.addTableModelListener(addSelectedAfterSelectionAction);
704 memberTableModel.getSelectionModel().addListSelectionListener(addSelectedAfterSelectionAction);
705 tb.add(addSelectedAfterSelectionAction);
706
707 // -- add at end action
708 AddSelectedAtEndAction addSelectedAtEndAction = new AddSelectedAtEndAction(
709 memberTableModel, selectionTableModel, re);
710 selectionTableModel.addTableModelListener(addSelectedAtEndAction);
711 tb.add(addSelectedAtEndAction);
712
713 tb.addSeparator();
714
715 // -- select members action
716 SelectedMembersForSelectionAction selectMembersForSelectionAction = new SelectedMembersForSelectionAction(
717 memberTableModel, selectionTableModel, re.getLayer());
718 selectionTableModel.addTableModelListener(selectMembersForSelectionAction);
719 memberTableModel.addTableModelListener(selectMembersForSelectionAction);
720 tb.add(selectMembersForSelectionAction);
721
722 // -- select action
723 SelectPrimitivesForSelectedMembersAction selectAction = new SelectPrimitivesForSelectedMembersAction(
724 memberTable, memberTableModel, re.getLayer());
725 memberTable.getSelectionModel().addListSelectionListener(selectAction);
726 tb.add(selectAction);
727
728 tb.addSeparator();
729
730 // -- remove selected action
731 RemoveSelectedAction removeSelectedAction = new RemoveSelectedAction(memberTableModel, selectionTableModel, re.getLayer());
732 selectionTableModel.addTableModelListener(removeSelectedAction);
733 tb.add(removeSelectedAction);
734
735 return tb;
736 }
737
738 @Override
739 protected Dimension findMaxDialogSize() {
740 return new Dimension(700, 650);
741 }
742
743 @Override
744 public void setVisible(boolean visible) {
745 if (isVisible() == visible) {
746 return;
747 }
748 if (visible) {
749 tagEditorPanel.initAutoCompletion(getLayer());
750 }
751 super.setVisible(visible);
752 Clipboard clipboard = ClipboardUtils.getClipboard();
753 if (visible) {
754 leftButtonToolbar.sortBelowButton.setVisible(ExpertToggleAction.isExpert());
755 RelationDialogManager.getRelationDialogManager().positionOnScreen(this);
756 if (windowMenuItem == null) {
757 windowMenuItem = addToWindowMenu(this, getLayer().getName());
758 }
759 tagEditorPanel.requestFocusInWindow();
760 for (FlavorListener listener : clipboardListeners) {
761 clipboard.addFlavorListener(listener);
762 }
763 } else {
764 // make sure all registered listeners are unregistered
765 //
766 memberTable.stopHighlighting();
767 selectionTableModel.unregister();
768 memberTableModel.unregister();
769 memberTable.unregisterListeners();
770 if (windowMenuItem != null) {
771 MainApplication.getMenu().windowMenu.remove(windowMenuItem);
772 windowMenuItem = null;
773 }
774 for (FlavorListener listener : clipboardListeners) {
775 clipboard.removeFlavorListener(listener);
776 }
777 dispose();
778 }
779 }
780
781 /**
782 * Adds current relation editor to the windows menu (in the "volatile" group)
783 * @param re relation editor
784 * @param layerName layer name
785 * @return created menu item
786 */
787 protected static JMenuItem addToWindowMenu(IRelationEditor re, String layerName) {
788 Relation r = re.getRelation();
789 String name = r == null ? tr("New Relation") : r.getLocalName();
790 JosmAction focusAction = new JosmAction(
791 tr("Relation Editor: {0}", name == null && r != null ? r.getId() : name),
792 "dialogs/relationlist",
793 tr("Focus Relation Editor with relation ''{0}'' in layer ''{1}''", name, layerName),
794 null, false, false) {
795 @Override
796 public void actionPerformed(ActionEvent e) {
797 ((RelationEditor) getValue("relationEditor")).setVisible(true);
798 }
799 };
800 focusAction.putValue("relationEditor", re);
801 return MainMenu.add(MainApplication.getMenu().windowMenu, focusAction, MainMenu.WINDOW_MENU_GROUP.VOLATILE);
802 }
803
804 /**
805 * checks whether the current relation has members referring to itself. If so,
806 * warns the users and provides an option for removing these members.
807 * @param memberTableModel member table model
808 * @param relation relation
809 */
810 protected static void cleanSelfReferences(MemberTableModel memberTableModel, Relation relation) {
811 List<OsmPrimitive> toCheck = new ArrayList<>();
812 toCheck.add(relation);
813 if (memberTableModel.hasMembersReferringTo(toCheck)) {
814 int ret = ConditionalOptionPaneUtil.showOptionDialog(
815 "clean_relation_self_references",
816 Main.parent,
817 tr("<html>There is at least one member in this relation referring<br>"
818 + "to the relation itself.<br>"
819 + "This creates circular dependencies and is discouraged.<br>"
820 + "How do you want to proceed with circular dependencies?</html>"),
821 tr("Warning"),
822 JOptionPane.YES_NO_OPTION,
823 JOptionPane.WARNING_MESSAGE,
824 new String[]{tr("Remove them, clean up relation"), tr("Ignore them, leave relation as is")},
825 tr("Remove them, clean up relation")
826 );
827 switch(ret) {
828 case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION:
829 case JOptionPane.CLOSED_OPTION:
830 case JOptionPane.NO_OPTION:
831 return;
832 case JOptionPane.YES_OPTION:
833 memberTableModel.removeMembersReferringTo(toCheck);
834 break;
835 default: // Do nothing
836 }
837 }
838 }
839
840 private void registerCopyPasteAction(AbstractAction action, Object actionName, KeyStroke shortcut,
841 JRootPane rootPane, JTable... tables) {
842 int mods = shortcut.getModifiers();
843 int code = shortcut.getKeyCode();
844 if (code != KeyEvent.VK_INSERT && (mods == 0 || mods == InputEvent.SHIFT_DOWN_MASK)) {
845 Logging.info(tr("Sorry, shortcut \"{0}\" can not be enabled in Relation editor dialog"), shortcut);
846 return;
847 }
848 rootPane.getActionMap().put(actionName, action);
849 rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(shortcut, actionName);
850 // Assign also to JTables because they have their own Copy&Paste implementation
851 // (which is disabled in this case but eats key shortcuts anyway)
852 for (JTable table : tables) {
853 table.getInputMap(JComponent.WHEN_FOCUSED).put(shortcut, actionName);
854 table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(shortcut, actionName);
855 table.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(shortcut, actionName);
856 }
857 if (action instanceof FlavorListener) {
858 clipboardListeners.add((FlavorListener) action);
859 }
860 }
861
862 /**
863 * Exception thrown when user aborts add operation.
864 */
865 public static class AddAbortException extends Exception {
866 }
867
868 /**
869 * Asks confirmationbefore adding a primitive.
870 * @param primitive primitive to add
871 * @return {@code true} is user confirms the operation, {@code false} otherwise
872 * @throws AddAbortException if user aborts operation
873 */
874 public static boolean confirmAddingPrimitive(OsmPrimitive primitive) throws AddAbortException {
875 String msg = tr("<html>This relation already has one or more members referring to<br>"
876 + "the object ''{0}''<br>"
877 + "<br>"
878 + "Do you really want to add another relation member?</html>",
879 Utils.escapeReservedCharactersHTML(primitive.getDisplayName(DefaultNameFormatter.getInstance()))
880 );
881 int ret = ConditionalOptionPaneUtil.showOptionDialog(
882 "add_primitive_to_relation",
883 Main.parent,
884 msg,
885 tr("Multiple members referring to same object."),
886 JOptionPane.YES_NO_CANCEL_OPTION,
887 JOptionPane.WARNING_MESSAGE,
888 null,
889 null
890 );
891 switch(ret) {
892 case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION:
893 case JOptionPane.YES_OPTION:
894 return true;
895 case JOptionPane.NO_OPTION:
896 case JOptionPane.CLOSED_OPTION:
897 return false;
898 case JOptionPane.CANCEL_OPTION:
899 default:
900 throw new AddAbortException();
901 }
902 }
903
904 /**
905 * Warn about circular references.
906 * @param primitive the concerned primitive
907 */
908 public static void warnOfCircularReferences(OsmPrimitive primitive) {
909 String msg = tr("<html>You are trying to add a relation to itself.<br>"
910 + "<br>"
911 + "This creates circular references and is therefore discouraged.<br>"
912 + "Skipping relation ''{0}''.</html>",
913 Utils.escapeReservedCharactersHTML(primitive.getDisplayName(DefaultNameFormatter.getInstance())));
914 JOptionPane.showMessageDialog(
915 Main.parent,
916 msg,
917 tr("Warning"),
918 JOptionPane.WARNING_MESSAGE);
919 }
920
921 /**
922 * Adds primitives to a given relation.
923 * @param orig The relation to modify
924 * @param primitivesToAdd The primitives to add as relation members
925 * @return The resulting command
926 * @throws IllegalArgumentException if orig is null
927 */
928 public static Command addPrimitivesToRelation(final Relation orig, Collection<? extends OsmPrimitive> primitivesToAdd) {
929 CheckParameterUtil.ensureParameterNotNull(orig, "orig");
930 try {
931 final Collection<TaggingPreset> presets = TaggingPresets.getMatchingPresets(
932 EnumSet.of(TaggingPresetType.forPrimitive(orig)), orig.getKeys(), false);
933 Relation relation = new Relation(orig);
934 boolean modified = false;
935 for (OsmPrimitive p : primitivesToAdd) {
936 if (p instanceof Relation && orig.equals(p)) {
937 if (!GraphicsEnvironment.isHeadless()) {
938 warnOfCircularReferences(p);
939 }
940 continue;
941 } else if (MemberTableModel.hasMembersReferringTo(relation.getMembers(), Collections.singleton(p))
942 && !confirmAddingPrimitive(p)) {
943 continue;
944 }
945 final Set<String> roles = findSuggestedRoles(presets, p);
946 relation.addMember(new RelationMember(roles.size() == 1 ? roles.iterator().next() : "", p));
947 modified = true;
948 }
949 return modified ? new ChangeCommand(orig, relation) : null;
950 } catch (AddAbortException ign) {
951 Logging.trace(ign);
952 return null;
953 }
954 }
955
956 protected static Set<String> findSuggestedRoles(final Collection<TaggingPreset> presets, OsmPrimitive p) {
957 final Set<String> roles = new HashSet<>();
958 for (TaggingPreset preset : presets) {
959 String role = preset.suggestRoleForOsmPrimitive(p);
960 if (role != null && !role.isEmpty()) {
961 roles.add(role);
962 }
963 }
964 return roles;
965 }
966
967 class MemberTableDblClickAdapter extends MouseAdapter {
968 @Override
969 public void mouseClicked(MouseEvent e) {
970 if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount() == 2) {
971 new EditAction(memberTable, memberTableModel, getLayer()).actionPerformed(null);
972 }
973 }
974 }
975}
Note: See TracBrowser for help on using the repository browser.