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

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

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