001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.gui.preferences; 003 004import static org.openstreetmap.josm.tools.I18n.tr; 005 006import java.awt.BorderLayout; 007import java.awt.Component; 008import java.awt.Container; 009import java.awt.Font; 010import java.awt.FontMetrics; 011import java.awt.GridBagConstraints; 012import java.awt.GridBagLayout; 013import java.awt.event.MouseWheelEvent; 014import java.awt.event.MouseWheelListener; 015import java.util.ArrayList; 016import java.util.Collection; 017import java.util.Collections; 018import java.util.HashSet; 019import java.util.Iterator; 020import java.util.LinkedList; 021import java.util.List; 022import java.util.NoSuchElementException; 023import java.util.Objects; 024import java.util.OptionalInt; 025import java.util.Set; 026import java.util.function.Predicate; 027import java.util.stream.IntStream; 028 029import javax.swing.BorderFactory; 030import javax.swing.Icon; 031import javax.swing.ImageIcon; 032import javax.swing.JLabel; 033import javax.swing.JOptionPane; 034import javax.swing.JPanel; 035import javax.swing.JScrollPane; 036import javax.swing.JTabbedPane; 037import javax.swing.SwingConstants; 038import javax.swing.UIManager; 039import javax.swing.event.ChangeEvent; 040import javax.swing.event.ChangeListener; 041 042import org.openstreetmap.josm.actions.ExpertToggleAction; 043import org.openstreetmap.josm.actions.ExpertToggleAction.ExpertModeChangeListener; 044import org.openstreetmap.josm.actions.RestartAction; 045import org.openstreetmap.josm.gui.HelpAwareOptionPane; 046import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec; 047import org.openstreetmap.josm.gui.MainApplication; 048import org.openstreetmap.josm.gui.preferences.advanced.AdvancedPreference; 049import org.openstreetmap.josm.gui.preferences.audio.AudioPreference; 050import org.openstreetmap.josm.gui.preferences.display.ColorPreference; 051import org.openstreetmap.josm.gui.preferences.display.DisplayPreference; 052import org.openstreetmap.josm.gui.preferences.display.DrawingPreference; 053import org.openstreetmap.josm.gui.preferences.display.GPXPreference; 054import org.openstreetmap.josm.gui.preferences.display.GridPreference; 055import org.openstreetmap.josm.gui.preferences.display.LafPreference; 056import org.openstreetmap.josm.gui.preferences.display.LanguagePreference; 057import org.openstreetmap.josm.gui.preferences.imagery.ImageryPreference; 058import org.openstreetmap.josm.gui.preferences.map.BackupPreference; 059import org.openstreetmap.josm.gui.preferences.map.MapPaintPreference; 060import org.openstreetmap.josm.gui.preferences.map.TaggingPresetPreference; 061import org.openstreetmap.josm.gui.preferences.plugin.PluginPreference; 062import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference; 063import org.openstreetmap.josm.gui.preferences.remotecontrol.RemoteControlPreference; 064import org.openstreetmap.josm.gui.preferences.server.ProxyPreference; 065import org.openstreetmap.josm.gui.preferences.server.ServerAccessPreference; 066import org.openstreetmap.josm.gui.preferences.shortcut.ShortcutPreference; 067import org.openstreetmap.josm.gui.preferences.validator.ValidatorPreference; 068import org.openstreetmap.josm.gui.preferences.validator.ValidatorTagCheckerRulesPreference; 069import org.openstreetmap.josm.gui.preferences.validator.ValidatorTestsPreference; 070import org.openstreetmap.josm.gui.util.GuiHelper; 071import org.openstreetmap.josm.plugins.PluginDownloadTask; 072import org.openstreetmap.josm.plugins.PluginHandler; 073import org.openstreetmap.josm.plugins.PluginInformation; 074import org.openstreetmap.josm.tools.GBC; 075import org.openstreetmap.josm.tools.ImageProvider; 076import org.openstreetmap.josm.tools.Logging; 077import org.openstreetmap.josm.tools.Pair; 078import org.openstreetmap.josm.tools.Utils; 079import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler; 080 081/** 082 * The preference settings. 083 * 084 * @author imi 085 */ 086public final class PreferenceTabbedPane extends JTabbedPane implements ExpertModeChangeListener, ChangeListener { 087 088 private final class PluginDownloadAfterTask implements Runnable { 089 private final PluginPreference preference; 090 private final PluginDownloadTask task; 091 private final Set<PluginInformation> toDownload; 092 093 private PluginDownloadAfterTask(PluginPreference preference, PluginDownloadTask task, 094 Set<PluginInformation> toDownload) { 095 this.preference = preference; 096 this.task = task; 097 this.toDownload = toDownload; 098 } 099 100 @Override 101 public void run() { 102 boolean requiresRestart = false; 103 104 for (PreferenceSetting setting : settingsInitialized) { 105 if (setting.ok()) { 106 requiresRestart = true; 107 } 108 } 109 110 // build the messages. We only display one message, including the status information from the plugin download task 111 // and - if necessary - a hint to restart JOSM 112 // 113 StringBuilder sb = new StringBuilder(); 114 sb.append("<html>"); 115 if (task != null && !task.isCanceled()) { 116 PluginHandler.refreshLocalUpdatedPluginInfo(task.getDownloadedPlugins()); 117 sb.append(PluginPreference.buildDownloadSummary(task)); 118 } 119 if (requiresRestart) { 120 sb.append(tr("You have to restart JOSM for some settings to take effect.")) 121 .append("<br/><br/>") 122 .append(tr("Would you like to restart now?")); 123 } 124 sb.append("</html>"); 125 126 // display the message, if necessary 127 // 128 if (requiresRestart) { 129 final ButtonSpec[] options = RestartAction.getButtonSpecs(); 130 if (0 == HelpAwareOptionPane.showOptionDialog( 131 MainApplication.getMainFrame(), 132 sb.toString(), 133 tr("Restart"), 134 JOptionPane.INFORMATION_MESSAGE, 135 null, /* no special icon */ 136 options, 137 options[0], 138 null /* no special help */ 139 )) { 140 MainApplication.getMenu().restart.actionPerformed(null); 141 } 142 } else if (task != null && !task.isCanceled()) { 143 Collection<PluginInformation> failed = task.getFailedPlugins(); 144 JOptionPane.showMessageDialog( 145 MainApplication.getMainFrame(), 146 sb.toString(), 147 !failed.isEmpty() ? tr("Warning") : tr("Information"), 148 !failed.isEmpty() ? JOptionPane.WARNING_MESSAGE : JOptionPane.INFORMATION_MESSAGE 149 ); 150 } 151 152 // load the plugins that can be loaded at runtime 153 List<PluginInformation> newPlugins = preference.getNewlyActivatedPlugins(); 154 if (newPlugins != null) { 155 Collection<PluginInformation> downloadedPlugins = null; 156 if (task != null && !task.isCanceled()) { 157 downloadedPlugins = task.getDownloadedPlugins(); 158 } 159 List<PluginInformation> toLoad = new ArrayList<>(); 160 for (PluginInformation pi : newPlugins) { 161 if (toDownload.contains(pi) && downloadedPlugins != null && !downloadedPlugins.contains(pi)) { 162 continue; // failed download 163 } 164 if (pi.canloadatruntime) { 165 toLoad.add(pi); 166 } 167 } 168 // check if plugin dependencies can also be loaded 169 Collection<PluginInformation> allPlugins = new HashSet<>(toLoad); 170 allPlugins.addAll(PluginHandler.getPlugins()); 171 boolean removed; 172 do { 173 removed = false; 174 Iterator<PluginInformation> it = toLoad.iterator(); 175 while (it.hasNext()) { 176 if (!PluginHandler.checkRequiredPluginsPreconditions(null, allPlugins, it.next(), requiresRestart)) { 177 it.remove(); 178 removed = true; 179 } 180 } 181 } while (removed); 182 183 if (!toLoad.isEmpty()) { 184 PluginHandler.loadPlugins(PreferenceTabbedPane.this, toLoad, null); 185 } 186 } 187 188 if (MainApplication.getMainFrame() != null) { 189 MainApplication.getMainFrame().repaint(); 190 } 191 } 192 } 193 194 /** 195 * Allows PreferenceSettings to do validation of entered values when ok was pressed. 196 * If data is invalid then event can return false to cancel closing of preferences dialog. 197 * @since 10600 (functional interface) 198 */ 199 @FunctionalInterface 200 public interface ValidationListener { 201 /** 202 * Determines if preferences can be saved. 203 * @return True if preferences can be saved 204 */ 205 boolean validatePreferences(); 206 } 207 208 private interface PreferenceTab { 209 TabPreferenceSetting getTabPreferenceSetting(); 210 211 Component getComponent(); 212 } 213 214 /** 215 * Panel used for preference settings. 216 * @since 4968 217 */ 218 public static final class PreferencePanel extends JPanel implements PreferenceTab { 219 private final transient TabPreferenceSetting preferenceSetting; 220 221 private PreferencePanel(TabPreferenceSetting preferenceSetting) { 222 super(new GridBagLayout()); 223 this.preferenceSetting = Objects.requireNonNull(preferenceSetting, "preferenceSetting"); 224 buildPanel(); 225 } 226 227 private void buildPanel() { 228 setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); 229 JPanel headerPanel = new JPanel(new BorderLayout()); 230 add(headerPanel, GBC.eop().fill(GridBagConstraints.HORIZONTAL)); 231 232 JLabel label = new JLabel("<html>" + 233 "<b>" + preferenceSetting.getTitle() + "</b><br>" + 234 "<i>" + preferenceSetting.getDescription() + "</i></html>"); 235 label.setFont(label.getFont().deriveFont(Font.PLAIN)); 236 headerPanel.add(label, BorderLayout.CENTER); 237 238 ImageIcon icon = preferenceSetting.getIcon(ImageProvider.ImageSizes.SETTINGS_TAB); 239 headerPanel.add(new JLabel(icon), BorderLayout.EAST); 240 } 241 242 @Override 243 public TabPreferenceSetting getTabPreferenceSetting() { 244 return preferenceSetting; 245 } 246 247 @Override 248 public Component getComponent() { 249 return this; 250 } 251 } 252 253 /** 254 * Scroll pane used for large {@link PreferencePanel}s. 255 * @since 4968 256 */ 257 public static final class PreferenceScrollPane extends JScrollPane implements PreferenceTab { 258 private final transient TabPreferenceSetting preferenceSetting; 259 260 private PreferenceScrollPane(PreferencePanel preferencePanel) { 261 super(preferencePanel.getComponent()); 262 this.preferenceSetting = preferencePanel.getTabPreferenceSetting(); 263 GuiHelper.setDefaultIncrement(this); 264 setBorder(BorderFactory.createEmptyBorder()); 265 } 266 267 @Override 268 public TabPreferenceSetting getTabPreferenceSetting() { 269 return preferenceSetting; 270 } 271 272 @Override 273 public Component getComponent() { 274 return this; 275 } 276 } 277 278 // all created tabs 279 private final transient List<PreferenceTab> tabs = new ArrayList<>(); 280 private static final Collection<PreferenceSettingFactory> SETTINGS_FACTORIES = new LinkedList<>(); 281 private static final PreferenceSettingFactory ADVANCED_PREFERENCE_FACTORY = new AdvancedPreference.Factory(); 282 private final transient List<PreferenceSetting> settings = new ArrayList<>(); 283 284 // distinct list of tabs that have been initialized (we do not initialize tabs until they are displayed to speed up dialog startup) 285 private final transient List<PreferenceSetting> settingsInitialized = new ArrayList<>(); 286 287 final transient List<ValidationListener> validationListeners = new ArrayList<>(); 288 289 /** 290 * Add validation listener to currently open preferences dialog. Calling to removeValidationListener is not necessary, all listeners will 291 * be automatically removed when dialog is closed 292 * @param validationListener validation listener to add 293 */ 294 public void addValidationListener(ValidationListener validationListener) { 295 validationListeners.add(validationListener); 296 } 297 298 /** 299 * Construct a PreferencePanel for the preference settings. Layout is GridBagLayout 300 * and a centered title label and the description are added. 301 * @param caller Preference settings, that display a top level tab 302 * @return The created panel ready to add other controls. 303 */ 304 public PreferencePanel createPreferenceTab(TabPreferenceSetting caller) { 305 return createPreferenceTab(caller, false); 306 } 307 308 /** 309 * Construct a PreferencePanel for the preference settings. Layout is GridBagLayout 310 * and a centered title label and the description are added. 311 * @param caller Preference settings, that display a top level tab 312 * @param inScrollPane if <code>true</code> the added tab will show scroll bars 313 * if the panel content is larger than the available space 314 * @return The created panel ready to add other controls. 315 */ 316 public PreferencePanel createPreferenceTab(TabPreferenceSetting caller, boolean inScrollPane) { 317 PreferencePanel p = new PreferencePanel(Objects.requireNonNull(caller, "caller")); 318 tabs.add(inScrollPane ? new PreferenceScrollPane(p) : p); 319 return p; 320 } 321 322 private OptionalInt indexOfTab(Predicate<TabPreferenceSetting> predicate) { 323 return IntStream.range(0, getTabCount()) 324 .filter(i -> getComponentAt(i) instanceof PreferenceTab 325 && predicate.test(((PreferenceTab) getComponentAt(i)).getTabPreferenceSetting())) 326 .findFirst(); 327 } 328 329 private void selectTabBy(Predicate<TabPreferenceSetting> predicate) { 330 setSelectedIndex(indexOfTab(predicate).orElse(0)); 331 } 332 333 /** 334 * Selects a {@link TabPreferenceSetting} by its icon name 335 * @param name the icon name 336 */ 337 public void selectTabByName(String name) { 338 Objects.requireNonNull(name); 339 selectTabBy(tps -> Objects.equals(name, tps.getIconName())); 340 } 341 342 /** 343 * Selects a {@link TabPreferenceSetting} by class 344 * @param clazz preferences tab class 345 */ 346 public void selectTabByPref(Class<? extends TabPreferenceSetting> clazz) { 347 selectTabBy(clazz::isInstance); 348 } 349 350 /** 351 * Selects a {@link SubPreferenceSetting} by class 352 * @param clazz sub preferences tab class 353 * @return true if the specified preference settings have been selected, false otherwise. 354 */ 355 public boolean selectSubTabByPref(Class<? extends SubPreferenceSetting> clazz) { 356 try { 357 final SubPreferenceSetting sub = getSetting(clazz); 358 final TabPreferenceSetting tab = sub.getTabPreferenceSetting(this); 359 selectTabBy(tps -> tps.equals(tab)); 360 return tab.selectSubTab(sub); 361 } catch (NoSuchElementException e) { 362 Logging.trace(e); 363 return false; 364 } 365 } 366 367 /** 368 * Returns the currently selected preference and sub preference setting 369 * @return the currently selected preference and sub preference setting 370 */ 371 public Pair<Class<? extends TabPreferenceSetting>, Class<? extends SubPreferenceSetting>> getSelectedTab() { 372 final Component selected = getSelectedComponent(); 373 if (selected instanceof PreferenceTab) { 374 final TabPreferenceSetting setting = ((PreferenceTab) selected).getTabPreferenceSetting(); 375 return Pair.create(setting.getClass(), setting.getSelectedSubTab()); 376 } else { 377 return null; 378 } 379 } 380 381 /** 382 * Returns the {@code DisplayPreference} object. 383 * @return the {@code DisplayPreference} object. 384 */ 385 public DisplayPreference getDisplayPreference() { 386 return getSetting(DisplayPreference.class); 387 } 388 389 /** 390 * Returns the {@code PluginPreference} object. 391 * @return the {@code PluginPreference} object. 392 */ 393 public PluginPreference getPluginPreference() { 394 return getSetting(PluginPreference.class); 395 } 396 397 /** 398 * Returns the {@code ImageryPreference} object. 399 * @return the {@code ImageryPreference} object. 400 */ 401 public ImageryPreference getImageryPreference() { 402 return getSetting(ImageryPreference.class); 403 } 404 405 /** 406 * Returns the {@code ShortcutPreference} object. 407 * @return the {@code ShortcutPreference} object. 408 */ 409 public ShortcutPreference getShortcutPreference() { 410 return getSetting(ShortcutPreference.class); 411 } 412 413 /** 414 * Returns the {@code ServerAccessPreference} object. 415 * @return the {@code ServerAccessPreference} object. 416 * @since 6523 417 */ 418 public ServerAccessPreference getServerPreference() { 419 return getSetting(ServerAccessPreference.class); 420 } 421 422 /** 423 * Returns the {@code ValidatorPreference} object. 424 * @return the {@code ValidatorPreference} object. 425 * @since 6665 426 */ 427 public ValidatorPreference getValidatorPreference() { 428 return getSetting(ValidatorPreference.class); 429 } 430 431 /** 432 * Saves preferences. 433 */ 434 public void savePreferences() { 435 // create a task for downloading plugins if the user has activated, yet not downloaded, new plugins 436 final PluginPreference preference = getPluginPreference(); 437 if (preference != null) { 438 final Set<PluginInformation> toDownload = preference.getPluginsScheduledForUpdateOrDownload(); 439 final PluginDownloadTask task; 440 if (!Utils.isEmpty(toDownload)) { 441 task = new PluginDownloadTask(this, toDownload, tr("Download plugins")); 442 } else { 443 task = null; 444 } 445 446 // this is the task which will run *after* the plugins are downloaded 447 final Runnable continuation = new PluginDownloadAfterTask(preference, task, toDownload); 448 449 if (task != null) { 450 // if we have to launch a plugin download task we do it asynchronously, followed 451 // by the remaining "save preferences" activities run on the Swing EDT. 452 MainApplication.worker.submit(task); 453 MainApplication.worker.submit(() -> GuiHelper.runInEDT(continuation)); 454 } else { 455 // no need for asynchronous activities. Simply run the remaining "save preference" 456 // activities on this thread (we are already on the Swing EDT 457 continuation.run(); 458 } 459 } 460 } 461 462 /** 463 * If the dialog is closed with Ok, the preferences will be stored to the preferences- 464 * file, otherwise no change of the file happens. 465 */ 466 public PreferenceTabbedPane() { 467 super(SwingConstants.LEFT, JTabbedPane.SCROLL_TAB_LAYOUT); 468 super.addMouseWheelListener(new WheelListener(this)); 469 ExpertToggleAction.addExpertModeChangeListener(this); 470 } 471 472 /** 473 * Constructs GUI. 474 */ 475 public void buildGui() { 476 Collection<PreferenceSettingFactory> factories = new ArrayList<>(SETTINGS_FACTORIES); 477 factories.addAll(PluginHandler.getPreferenceSetting()); 478 factories.add(ADVANCED_PREFERENCE_FACTORY); 479 480 for (PreferenceSettingFactory factory : factories) { 481 if (factory != null) { 482 PreferenceSetting setting = factory.createPreferenceSetting(); 483 if (setting instanceof TabPreferenceSetting && ((TabPreferenceSetting) setting).getIconName() == null) { 484 Logging.error("Invalid setting (Icon missing): " + setting.getClass().getName()); 485 setting = null; 486 } 487 if (setting != null) { 488 settings.add(setting); 489 } 490 } 491 } 492 addGUITabs(false); 493 super.getModel().addChangeListener(this); 494 } 495 496 private void addGUITabsForSetting(Icon icon, TabPreferenceSetting tps, int maxWidth) { 497 for (PreferenceTab tab : tabs) { 498 if (tab.getTabPreferenceSetting().equals(tps)) { 499 insertGUITabsForSetting(icon, tps, tab.getComponent(), getTabCount(), maxWidth); 500 } 501 } 502 } 503 504 private int insertGUITabsForSetting(Icon icon, TabPreferenceSetting tps, int index, int maxWidth) { 505 int position = index; 506 for (PreferenceTab tab : tabs) { 507 if (tab.getTabPreferenceSetting().equals(tps)) { 508 insertGUITabsForSetting(icon, tps, tab.getComponent(), position, maxWidth); 509 position++; 510 } 511 } 512 return position - 1; 513 } 514 515 private void insertGUITabsForSetting(Icon icon, TabPreferenceSetting tps, final Component component, int position, int maxWidth) { 516 // macOS / AquaLookAndFeel does not support horizontal tabs, see https://josm.openstreetmap.de/ticket/7548#comment:80 517 String title = "Aqua".equals(UIManager.getLookAndFeel().getID()) ? null : htmlTabTitle(tps.getTitle(), maxWidth); 518 insertTab(title, icon, component, tps.getTooltip(), position); 519 } 520 521 private static String htmlTabTitle(String title, int maxWidth) { 522 // Width is set to force left alignment, see https://stackoverflow.com/a/33781096/2257172 523 return "<html><div style='padding-left:5px; width:" + maxWidth + "px'>" + title + "</div></html>"; 524 } 525 526 private void addGUITabs(boolean clear) { 527 boolean expert = ExpertToggleAction.isExpert(); 528 if (clear) { 529 removeAll(); 530 } 531 // Compute max tab length in pixels 532 int maxWidth = computeMaxTabWidth(); 533 // Inspect each tab setting 534 for (PreferenceSetting setting : settings) { 535 if (setting instanceof TabPreferenceSetting) { 536 TabPreferenceSetting tps = (TabPreferenceSetting) setting; 537 if (expert || !tps.isExpert()) { 538 ImageIcon icon = tps.getIcon(ImageProvider.ImageSizes.LARGEICON); 539 if (settingsInitialized.contains(tps)) { 540 // If it has been initialized, add corresponding tab(s) 541 addGUITabsForSetting(icon, tps, maxWidth); 542 } else { 543 // If it has not been initialized, create an empty tab with only icon and tooltip 544 insertGUITabsForSetting(icon, tps, new PreferencePanel(tps), getTabCount(), maxWidth); 545 } 546 } 547 } else if (!(setting instanceof SubPreferenceSetting)) { 548 Logging.warn("Ignoring preferences "+setting); 549 } 550 } 551 // Hide empty TabPreferenceSetting (only present for plugins) 552 for (DefaultTabPreferenceSetting tps : Utils.filteredCollection(settings, DefaultTabPreferenceSetting.class)) { 553 if (!tps.canBeHidden() || Utils.filteredCollection(settings, SubPreferenceSetting.class).stream() 554 .anyMatch(s -> s.getTabPreferenceSetting(this) == tps)) { 555 continue; 556 } 557 indexOfTab(tps::equals).ifPresent(index -> { 558 remove(index); 559 Logging.debug("{0}: hiding empty {1}", getClass().getSimpleName(), tps); 560 }); 561 } 562 setSelectedIndex(-1); 563 } 564 565 private int computeMaxTabWidth() { 566 FontMetrics fm = getFontMetrics(getFont()); 567 return settings.stream().filter(TabPreferenceSetting.class::isInstance) 568 .map(TabPreferenceSetting.class::cast).map(TabPreferenceSetting::getTitle) 569 .filter(Objects::nonNull).mapToInt(fm::stringWidth).max().orElse(120); 570 } 571 572 @Override 573 public void expertChanged(boolean isExpert) { 574 Component sel = getSelectedComponent(); 575 addGUITabs(true); 576 int index = -1; 577 if (sel != null) { 578 index = indexOfComponent(sel); 579 } 580 setSelectedIndex(Math.max(index, 0)); 581 } 582 583 /** 584 * Returns a list of all preferences settings 585 * @return a list of all preferences settings 586 */ 587 public List<PreferenceSetting> getSettings() { 588 return Collections.unmodifiableList(settings); 589 } 590 591 /** 592 * Returns the preferences setting for the given class 593 * @param clazz the preference setting class 594 * @param <T> the preference setting type 595 * @return the preferences setting for the given class 596 * @throws NoSuchElementException if there is no such value 597 */ 598 public <T extends PreferenceSetting> T getSetting(Class<? extends T> clazz) { 599 return Utils.filteredCollection(settings, clazz).iterator().next(); 600 } 601 602 static { 603 // order is important! 604 SETTINGS_FACTORIES.add(new DisplayPreference.Factory()); 605 SETTINGS_FACTORIES.add(new DrawingPreference.Factory()); 606 SETTINGS_FACTORIES.add(new GPXPreference.Factory()); 607 SETTINGS_FACTORIES.add(new ColorPreference.Factory()); 608 SETTINGS_FACTORIES.add(new LafPreference.Factory()); 609 SETTINGS_FACTORIES.add(new LanguagePreference.Factory()); 610 611 SETTINGS_FACTORIES.add(new ServerAccessPreference.Factory()); 612 SETTINGS_FACTORIES.add(new ProxyPreference.Factory()); 613 SETTINGS_FACTORIES.add(new ProjectionPreference.Factory()); 614 SETTINGS_FACTORIES.add(new GridPreference.Factory()); 615 SETTINGS_FACTORIES.add(new MapPaintPreference.Factory()); 616 SETTINGS_FACTORIES.add(new TaggingPresetPreference.Factory()); 617 SETTINGS_FACTORIES.add(new BackupPreference.Factory()); 618 SETTINGS_FACTORIES.add(new PluginPreference.Factory()); 619 SETTINGS_FACTORIES.add(MainApplication.getToolbar()); 620 SETTINGS_FACTORIES.add(new AudioPreference.Factory()); 621 SETTINGS_FACTORIES.add(new ShortcutPreference.Factory()); 622 SETTINGS_FACTORIES.add(new ValidatorPreference.Factory()); 623 SETTINGS_FACTORIES.add(new ValidatorTestsPreference.Factory()); 624 SETTINGS_FACTORIES.add(new ValidatorTagCheckerRulesPreference.Factory()); 625 SETTINGS_FACTORIES.add(new RemoteControlPreference.Factory()); 626 SETTINGS_FACTORIES.add(new ImageryPreference.Factory()); 627 } 628 629 /** 630 * This mouse wheel listener reacts when a scroll is carried out over the 631 * tab strip and scrolls one tab/down or up, selecting it immediately. 632 */ 633 static final class WheelListener implements MouseWheelListener { 634 635 final JTabbedPane tabbedPane; 636 637 WheelListener(JTabbedPane tabbedPane) { 638 this.tabbedPane = tabbedPane; 639 } 640 641 @Override 642 public void mouseWheelMoved(MouseWheelEvent wev) { 643 // Ensure the cursor is over the tab strip 644 if (tabbedPane.indexAtLocation(wev.getPoint().x, wev.getPoint().y) < 0) 645 return; 646 647 // Get currently selected tab && ensure the new tab index is sound 648 int newTab = Utils.clamp(tabbedPane.getSelectedIndex() + wev.getWheelRotation(), 649 0, tabbedPane.getTabCount() - 1); 650 651 tabbedPane.setSelectedIndex(newTab); 652 } 653 } 654 655 @Override 656 public void stateChanged(ChangeEvent e) { 657 int index = getSelectedIndex(); 658 Component sel = getSelectedComponent(); 659 if (index > -1 && sel instanceof PreferenceTab) { 660 PreferenceTab tab = (PreferenceTab) sel; 661 TabPreferenceSetting preferenceSettings = tab.getTabPreferenceSetting(); 662 if (!settingsInitialized.contains(preferenceSettings)) { 663 try { 664 getModel().removeChangeListener(this); 665 preferenceSettings.addGui(this); 666 // Add GUI for sub preferences 667 for (PreferenceSetting setting : settings) { 668 if (setting instanceof SubPreferenceSetting) { 669 addSubPreferenceSetting(preferenceSettings, (SubPreferenceSetting) setting); 670 } 671 } 672 Icon icon = getIconAt(index); 673 remove(index); 674 if (index <= insertGUITabsForSetting(icon, preferenceSettings, index, computeMaxTabWidth())) { 675 setSelectedIndex(index); 676 } 677 } catch (SecurityException ex) { 678 Logging.error(ex); 679 } catch (RuntimeException ex) { 680 // allow to change most settings even if e.g. a plugin fails 681 BugReportExceptionHandler.handleException(ex); 682 } finally { 683 settingsInitialized.add(preferenceSettings); 684 getModel().addChangeListener(this); 685 } 686 } 687 Container ancestor = getTopLevelAncestor(); 688 if (ancestor instanceof PreferenceDialog) { 689 ((PreferenceDialog) ancestor).setHelpContext(preferenceSettings.getHelpContext()); 690 } 691 } 692 } 693 694 private void addSubPreferenceSetting(TabPreferenceSetting preferenceSettings, SubPreferenceSetting sps) { 695 if (sps.getTabPreferenceSetting(this) == preferenceSettings) { 696 try { 697 sps.addGui(this); 698 } catch (SecurityException ex) { 699 Logging.error(ex); 700 } catch (RuntimeException ex) { 701 BugReportExceptionHandler.handleException(ex); 702 } finally { 703 settingsInitialized.add(sps); 704 } 705 } 706 } 707}