Ticket #6953: bigShowHideButton.patch

File bigShowHideButton.patch, 16.0 KB (added by akks, 8 years ago)
  • src/org/openstreetmap/josm/gui/HideableButton.java

     
     1// License: GPL. Copyright 2007 by Immanuel Scholz and others
     2package org.openstreetmap.josm.gui;
     3
     4import javax.swing.Icon;
     5
     6/**
     7 * An interface to provide showing/hiding method for buttons,
     8 * when hidden state is stored in preferences
     9 */
     10interface HideableButton {
     11    public void applyButtonHiddenPreferences();
     12    public void setButtonHidden(boolean b);
     13    public void showButton();
     14    public void hideButton();
     15    public String getActionName();
     16    public Icon getIcon();
     17    public boolean isButtonVisible();
     18    public void setShowHideButtonListener(ShowHideButtonListener l);
     19}
  • src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

     
    1212import java.awt.GridBagLayout;
    1313import java.awt.GridLayout;
    1414import java.awt.Image;
    15 import java.awt.Point;
    1615import java.awt.Rectangle;
    1716import java.awt.Toolkit;
    1817import java.awt.event.AWTEventListener;
     
    4645import org.openstreetmap.josm.gui.dialogs.DialogsPanel.Action;
    4746import org.openstreetmap.josm.gui.help.HelpUtil;
    4847import org.openstreetmap.josm.gui.help.Helpful;
     48import org.openstreetmap.josm.gui.ShowHideButtonListener;
    4949import org.openstreetmap.josm.gui.util.RedirectInputMap;
    5050import org.openstreetmap.josm.gui.SideButton;
    5151import org.openstreetmap.josm.tools.GBC;
     
    5656 * This class is a toggle dialog that can be turned on and off.
    5757 *
    5858 */
    59 public class ToggleDialog extends JPanel implements Helpful, AWTEventListener {
     59public class ToggleDialog extends JPanel implements ShowHideButtonListener, Helpful, AWTEventListener {
    6060
    6161    /** The action to toggle this dialog */
    6262    protected ToggleDialogAction toggleAction;
     
    9393    protected JDialog detachedDialog;
    9494
    9595    protected JToggleButton button;
    96     protected boolean buttonHidden;
    9796    private JPanel buttonsPanel;
    9897
    9998    /** holds the menu entry in the windows menu. Required to properly
     
    143142        isDocked = Main.pref.getBoolean(preferencePrefix+".docked", true);
    144143        isCollapsed = Main.pref.getBoolean(preferencePrefix+".minimized", false);
    145144
    146         buttonHidden = Main.pref.getBoolean(preferencePrefix+".button_hidden", false);
    147 
    148145        RedirectInputMap.redirectToMainContentPane(this);
    149146
    150147        windowMenuItem = MainMenu.addWithCheckbox(Main.main.menu.windowMenu,
     
    224221            expand();
    225222            dialogsPanel.reconstruct(Action.COLLAPSED_TO_DEFAULT, this);
    226223        } else if (!isDialogShowing()) {
    227             if (isButtonHidden()) {
    228                 showButtonImpl();
    229             }
     224//            if (isButtonHidden()) {
     225//                showButtonImpl();
     226//            }
    230227            showDialog();
    231228            if (isDocked && isCollapsed) {
    232229                expand();
     
    238235        }
    239236    }
    240237
    241     public void hideButton() {
    242         if (!button.isVisible())
    243             throw new AssertionError();
     238    @Override
     239    public void buttonHidden() {
    244240        if ((Boolean) toggleAction.getValue("selected")) {
    245241            toggleAction.actionPerformed(null);
    246242        }
    247         button.setVisible(false);
    248         setButtonHidden(true);
    249243    }
    250244
    251     public void showButton() {
    252         showButtonImpl();
     245    public void buttonShown() {
    253246        unfurlDialog();
    254247    }
    255248
    256     protected void showButtonImpl() {
    257         if (button.isVisible())
    258             throw new AssertionError();
    259         button.setVisible(true);
    260         setButtonHidden(false);
    261     }
    262249
    263250    /**
    264251     * Hides the dialog
     
    622609        return isShowing && isDocked && isCollapsed;
    623610    }
    624611
    625     public boolean isButtonHidden() {
    626         return buttonHidden;
    627     }
    628 
    629     protected void setButtonHidden(boolean buttonHidden) {
    630         this.buttonHidden = buttonHidden;
    631         Main.pref.put(preferencePrefix+".button_hidden", buttonHidden);
    632     }
    633 
    634 
    635612    public void setButton(JToggleButton button) {
    636613        this.button = button;
    637         button.setVisible(!buttonHidden);
    638614    }
    639615
    640616    public JToggleButton getButton() {
    641617        return button;
    642618    }
    643 
     619   
    644620    /***
    645621     * The following methods are intended to be overridden, in order to customize
    646622     * the toggle dialog behavior.
  • src/org/openstreetmap/josm/gui/ShowHideButtonListener.java

     
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.gui;
     3
     4/**
     5 * When some component (ToggleDialog, for example) is linked to button a
     6 * and needs information about button showing/hiding events, this interface
     7 * is used, setting the listener should be implemented by @class HideableButton
     8 */
     9public interface ShowHideButtonListener {
     10    public void buttonShown();
     11    public void buttonHidden();
     12}
  • src/org/openstreetmap/josm/gui/IconToggleButton.java

     
    66import java.beans.PropertyChangeEvent;
    77import java.beans.PropertyChangeListener;
    88
     9import javax.swing.AbstractAction;
    910import javax.swing.Action;
     11import javax.swing.Icon;
    1012import javax.swing.JToggleButton;
    1113
     14import org.openstreetmap.josm.Main;
    1215import org.openstreetmap.josm.tools.Destroyable;
    1316
    1417/**
    1518 * Just a toggle button, with smaller border and icon only to display in
    1619 * MapFrame toolbars.
    17  *
    18  * @author imi
     20 * Also provides methods for storing hidden state in preferences
     21 * @author imi, akks
    1922 */
    20 public class IconToggleButton extends JToggleButton implements PropertyChangeListener, Destroyable {
     23public class IconToggleButton extends JToggleButton implements HideableButton, PropertyChangeListener, Destroyable {
    2124
    2225    public boolean groupbutton;
     26    private ShowHideButtonListener listener;
    2327
    2428    /**
    2529     * Construct the toggle button with the given action.
     
    5862        }
    5963        action.removePropertyChangeListener(this);
    6064    }
     65   
     66    @Override
     67    public void applyButtonHiddenPreferences() {
     68            String actionName = (String) getAction().getValue(AbstractAction.NAME);
     69            boolean hiddenFlag =
     70                    Main.pref.getBoolean(actionName + ".itbutton_hidden", false);
     71            setVisible(!hiddenFlag);   
     72    }
     73
     74    @Override
     75    public void setButtonHidden(boolean b) {
     76            String actionName = (String) getAction().getValue(AbstractAction.NAME);
     77            setVisible(!b);
     78            if (listener!=null) { // if someone wants to know about changes of visibility
     79                if (!b) listener.buttonShown(); else listener.buttonHidden();
     80            }
     81            Main.pref.put(actionName + ".itbutton_hidden", b);
     82           
     83    }
     84    @Override
     85    public void showButton() {
     86        setButtonHidden(false);
     87    }
     88    @Override
     89    public void hideButton() {
     90        setButtonHidden(true);
     91    }
     92
     93    @Override
     94    public String getActionName() {
     95        return (String) getAction().getValue(Action.NAME);
     96    }
     97
     98    @Override
     99    public Icon getIcon() {
     100        return (Icon) getAction().getValue(Action.SMALL_ICON);
     101    }
     102
     103    @Override
     104    public boolean isButtonVisible() {
     105        return isVisible();
     106    }
     107
     108    @Override
     109    public void setShowHideButtonListener(ShowHideButtonListener l) {
     110        listener = l;
     111    }
     112
     113 
    61114}
  • src/org/openstreetmap/josm/gui/MapFrame.java

     
    1313import java.awt.event.MouseWheelEvent;
    1414import java.awt.event.MouseWheelListener;
    1515import java.util.ArrayList;
     16import java.util.Collection;
    1617import java.util.HashMap;
    1718import java.util.List;
    1819import java.util.Map;
     
    106107    private final DialogsPanel dialogsPanel;
    107108
    108109    public final ButtonGroup toolGroup = new ButtonGroup();
     110   
     111    private List<IconToggleButton> allDialogButtons = new ArrayList<IconToggleButton>();
     112    private List<IconToggleButton> allMapModeButtons = new ArrayList<IconToggleButton>();
     113   
     114    private final ListAllButtonsAction listAllDialogsAction = new ListAllButtonsAction(allDialogButtons);
     115    private final ListAllButtonsAction listAllMapModesAction = new ListAllButtonsAction(allMapModeButtons);
     116    private final JButton listAllToggleDialogsButton = new JButton(listAllDialogsAction);
     117    private final JButton listAllMapModesButton = new JButton(listAllMapModesAction);
     118    {
     119        listAllDialogsAction.setButton(listAllToggleDialogsButton);
     120        listAllMapModesAction.setButton(listAllMapModesButton);
     121    }
    109122
    110     public final JButton otherButton = new JButton(new OtherButtonsAction());
    111 
    112123    /**
    113124     * Default width of the toggle dialog area.
    114125     */
     
    261272     */
    262273    public IconToggleButton addToggleDialog(final ToggleDialog dlg) {
    263274        final IconToggleButton button = new IconToggleButton(dlg.getToggleAction());
    264         button.addMouseListener(new PopupMenuLauncher(new JPopupMenu() {
    265             {
    266                 add(new AbstractAction() {
    267                     {
    268                         putValue(NAME, tr("Hide this button"));
    269                         putValue(SHORT_DESCRIPTION, tr("Click the arrow at the bottom to show it again."));
    270                     }
    271 
    272                     @Override
    273                     public void actionPerformed(ActionEvent e) {
    274                         dlg.hideButton();
    275                         validateToolBarToggle();
    276                     }
    277                 });
    278             }
    279         }));
     275        button.setShowHideButtonListener(dlg);
     276        addHideContextMenu(button);
    280277        dlg.setButton(button);
    281         if (button.isVisible()) {
    282             toolBarToggle.add(button);
    283         }
     278        toolBarToggle.add(button);
    284279        allDialogs.add(dlg);
     280        allDialogButtons.add(button);
     281        button.applyButtonHiddenPreferences();
    285282        if (dialogsPanel.initialized) {
    286283            dialogsPanel.add(dlg);
    287284        }
    288285        return button;
    289286    }
    290287
    291     public void validateToolBarToggle() {
    292         toolBarToggle.removeAll();
    293         for (ToggleDialog dlg : allDialogs) {
    294             if (dlg.getButton().isVisible()) {
    295                 toolBarToggle.add(dlg.getButton());
    296             }
    297         }
    298     }
    299288
     289
    300290    public void addMapMode(IconToggleButton b) {
    301291        toolBarActions.add(b);
    302292        toolGroup.add(b);
     293        allMapModeButtons.add(b);
    303294        if (b.getAction() instanceof MapMode) {
    304295            mapModes.add((MapMode) b.getAction());
    305296        } else
    306297            throw new IllegalArgumentException("MapMode action must be subclass of MapMode");
     298        addHideContextMenu(b);
     299        b.applyButtonHiddenPreferences();
    307300    }
    308301
    309302    /**
     
    362355        jb.setFloatable(false);
    363356        toolBarActions.setAlignmentX(0.5f);
    364357        jb.add(toolBarActions);
    365 
     358        listAllMapModesButton.setAlignmentX(0.5f);
     359        listAllMapModesButton.setBorder(null);
     360        listAllMapModesButton.setFont(listAllMapModesButton.getFont().deriveFont(Font.PLAIN));
     361        jb.add(listAllMapModesButton);
     362       
    366363        if(Main.pref.getBoolean("sidetoolbar.togglevisible", true)) {
    367364            jb.addSeparator(new Dimension(0,18));
    368365            toolBarToggle.setAlignmentX(0.5f);
    369366            jb.add(toolBarToggle);
    370             otherButton.setAlignmentX(0.5f);
    371             otherButton.setBorder(null);
    372             otherButton.setFont(otherButton.getFont().deriveFont(Font.PLAIN));
    373             jb.add(otherButton);
     367            listAllToggleDialogsButton.setAlignmentX(0.5f);
     368            listAllToggleDialogsButton.setBorder(null);
     369            listAllToggleDialogsButton.setFont(listAllToggleDialogsButton.getFont().deriveFont(Font.PLAIN));
     370            jb.add(listAllToggleDialogsButton);
    374371        }
    375372
    376373        if(Main.pref.getBoolean("sidetoolbar.visible", true))
     
    392389        }
    393390    }
    394391
    395     class OtherButtonsAction extends AbstractAction {
     392    private void addHideContextMenu(final IconToggleButton b) {
     393        //context menu
     394        b.addMouseListener(new PopupMenuLauncher(new JPopupMenu() {
     395            {
     396                add(new AbstractAction() {
     397                    {
     398                        putValue(NAME, tr("Hide this button"));
     399                        putValue(SHORT_DESCRIPTION, tr("Click the arrow at the bottom to show it again."));
     400                    }
     401                    @Override
     402                    public void actionPerformed(ActionEvent e) {
     403                        b.setButtonHidden(true);
     404                        validateToolBarsVisibility();
     405                    }
     406                });
     407            }
     408        }));
     409    }
     410   
     411        class ListAllButtonsAction extends AbstractAction {
    396412
    397         public OtherButtonsAction() {
     413        private JButton button;
     414        private Collection<? extends HideableButton> buttons;
     415       
     416               
     417        public ListAllButtonsAction(Collection<? extends HideableButton> buttons) {
     418            this.buttons = buttons;
    398419            putValue(NAME, ">>");
    399420        }
    400421
     422        public void setButton(JButton button) {
     423            this.button =  button;
     424        }
     425
    401426        @Override
    402427        public void actionPerformed(ActionEvent e) {
    403428            JPopupMenu menu = new JPopupMenu();
    404             for (final ToggleDialog t : allDialogs) {
     429            for (HideableButton b : buttons) {
     430                final HideableButton t = b;
    405431                menu.add(new JCheckBoxMenuItem(new AbstractAction() {
    406432                    {
    407                         putValue(NAME, t.getToggleAction().getValue(NAME));
    408                         putValue(SMALL_ICON, t.getToggleAction().getValue(SMALL_ICON));
    409                         putValue(SELECTED_KEY, !t.isButtonHidden());
     433                        putValue(NAME, t.getActionName());
     434                        putValue(SMALL_ICON, t.getIcon());
     435                        putValue(SELECTED_KEY, t.isButtonVisible());
    410436                        putValue(SHORT_DESCRIPTION, tr("Hide or show this toggle button"));
    411437                    }
    412438                    @Override
    413439                    public void actionPerformed(ActionEvent e) {
    414                         if ((Boolean) getValue(SELECTED_KEY)) {
    415                             t.showButton();
    416                             validateToolBarToggle();
    417                         } else {
    418                             t.hideButton();
    419                             validateToolBarToggle();
    420                         }
     440                        if ((Boolean) getValue(SELECTED_KEY)) t.showButton(); else t.hideButton();
     441                        validateToolBarsVisibility();
    421442                    }
    422443                }));
    423444            }
    424             Rectangle bounds = otherButton.getBounds();
    425             menu.show(otherButton, bounds.x+bounds.width, 0);
     445            Rectangle bounds = button.getBounds();
     446            menu.show(button, bounds.x + bounds.width, 0);
    426447        }
    427448    }
    428449
     450    public void validateToolBarsVisibility() {
     451        for (IconToggleButton b : allDialogButtons) {
     452            b.applyButtonHiddenPreferences();
     453        }
     454        toolBarToggle.repaint();
     455        for (IconToggleButton b : allMapModeButtons) {
     456            b.applyButtonHiddenPreferences();
     457        }
     458        toolBarActions.repaint();
     459    }
     460
    429461    /**
    430462     * Replies the instance of a toggle dialog of type <code>type</code> managed by this
    431463     * map frame