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

Last change on this file since 14027 was 14027, checked in by michael2402, 6 years ago

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