Please use the Apache issue tracking system for new NetBeans issues (https://issues.apache.org/jira/projects/NETBEANS0/issues) !!
View | Details | Raw Unified | Return to bug 216175 | Differences between
and this patch

Collapse All | Expand All

(-)a/core.io.ui/src/org/netbeans/core/io/ui/IOWindow.java (-1 / +2 lines)
 Lines 74-79    Link Here 
74
import org.openide.util.Utilities;
74
import org.openide.util.Utilities;
75
import org.openide.awt.MouseUtils;
75
import org.openide.awt.MouseUtils;
76
import org.openide.awt.TabbedPaneFactory;
76
import org.openide.awt.TabbedPaneFactory;
77
import org.openide.awt.ToolbarWithOverflow;
77
import org.openide.util.HelpCtx;
78
import org.openide.util.HelpCtx;
78
import org.openide.util.ImageUtilities;
79
import org.openide.util.ImageUtilities;
79
import org.openide.util.NbBundle;
80
import org.openide.util.NbBundle;
 Lines 210-216    Link Here 
210
            pane.addPropertyChangeListener(TabbedPaneFactory.PROP_CLOSE, this);
211
            pane.addPropertyChangeListener(TabbedPaneFactory.PROP_CLOSE, this);
211
            setFocusable(true);
212
            setFocusable(true);
212
213
213
            toolbar = new JToolBar();
214
            toolbar = new ToolbarWithOverflow();
214
            toolbar.setOrientation(JToolBar.VERTICAL);
215
            toolbar.setOrientation(JToolBar.VERTICAL);
215
            toolbar.setLayout(new BoxLayout(toolbar, BoxLayout.Y_AXIS));
216
            toolbar.setLayout(new BoxLayout(toolbar, BoxLayout.Y_AXIS));
216
            toolbar.setFloatable(false);
217
            toolbar.setFloatable(false);
(-)a/core.windows/src/org/netbeans/core/windows/view/ui/toolbars/ToolbarConfiguration.java (+2 lines)
 Lines 280-287    Link Here 
280
                if (comps[j] instanceof JComponent) {
280
                if (comps[j] instanceof JComponent) {
281
                    if (smallToolbarIcons) {
281
                    if (smallToolbarIcons) {
282
                        ((JComponent) comps[j]).putClientProperty("PreferredIconSize",null); //NOI18N
282
                        ((JComponent) comps[j]).putClientProperty("PreferredIconSize",null); //NOI18N
283
                        tb.putClientProperty("PreferredIconSize",null); //NOI18N
283
                    } else {
284
                    } else {
284
                        ((JComponent) comps[j]).putClientProperty("PreferredIconSize",Integer.valueOf(24)); //NOI18N
285
                        ((JComponent) comps[j]).putClientProperty("PreferredIconSize",Integer.valueOf(24)); //NOI18N
286
                        tb.putClientProperty("PreferredIconSize",Integer.valueOf(24)); //NOI18N
285
                    }
287
                    }
286
                }
288
                }
287
                //TODO add icon shadow for mac l&f?
289
                //TODO add icon shadow for mac l&f?
(-)a/editor/src/org/netbeans/modules/editor/NbEditorToolBar.java (-1 / +2 lines)
 Lines 97-102    Link Here 
97
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
97
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
98
import org.netbeans.modules.editor.impl.ToolbarActionsProvider;
98
import org.netbeans.modules.editor.impl.ToolbarActionsProvider;
99
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
99
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
100
import org.openide.awt.ToolbarWithOverflow;
100
import org.openide.filesystems.FileChangeAdapter;
101
import org.openide.filesystems.FileChangeAdapter;
101
import org.openide.filesystems.FileChangeListener;
102
import org.openide.filesystems.FileChangeListener;
102
import org.openide.filesystems.FileEvent;
103
import org.openide.filesystems.FileEvent;
 Lines 124-130    Link Here 
124
 * @version 1.00
125
 * @version 1.00
125
 */
126
 */
126
127
127
/* package */ final class NbEditorToolBar extends JToolBar {
128
/* package */ final class NbEditorToolBar extends ToolbarWithOverflow {
128
129
129
    // -J-Dorg.netbeans.modules.editor.NbEditorToolBar.level=FINE
130
    // -J-Dorg.netbeans.modules.editor.NbEditorToolBar.level=FINE
130
    private static final Logger LOG = Logger.getLogger(NbEditorToolBar.class.getName());
131
    private static final Logger LOG = Logger.getLogger(NbEditorToolBar.class.getName());
(-)a/openide.awt/apichanges.xml (+14 lines)
 Lines 50-55    Link Here 
50
<apidef name="awt">AWT API</apidef>
50
<apidef name="awt">AWT API</apidef>
51
</apidefs>
51
</apidefs>
52
<changes>
52
<changes>
53
    <change id="ToolbarWithOverflow">
54
      <api name="awt"/>
55
      <summary>ToolbarWithOverflow class that adds an overflow button when the toolbar becomes too small to show all the available actions.</summary>
56
      <version major="7" minor="50"/>
57
      <date day="7" month="8" year="2012"/>
58
      <author login="theofanis"/>
59
      <compatibility addition="yes" binary="compatible" source="compatible" deprecation="no" semantic="compatible" modification="no" deletion="no"/>
60
      <description>
61
          ToolbarWithOverflow class is added. It can be used to add an overflow button 
62
          when the toolbar becomes too small to show all the available actions.
63
      </description>
64
      <class package="org.openide.awt" name="ToolbarWithOverflow"/>
65
      <issue number="216175"/>
66
    </change>
53
    <change id="CheckForUpdatesProvider">
67
    <change id="CheckForUpdatesProvider">
54
        <api name="awt"/>
68
        <api name="awt"/>
55
        <summary>Support for Check for Updates feature</summary>
69
        <summary>Support for Check for Updates feature</summary>
(-)a/openide.awt/manifest.mf (-1 / +1 lines)
 Lines 2-6    Link Here 
2
OpenIDE-Module: org.openide.awt
2
OpenIDE-Module: org.openide.awt
3
OpenIDE-Module-Localizing-Bundle: org/openide/awt/Bundle.properties
3
OpenIDE-Module-Localizing-Bundle: org/openide/awt/Bundle.properties
4
AutoUpdate-Essential-Module: true
4
AutoUpdate-Essential-Module: true
5
OpenIDE-Module-Specification-Version: 7.47
5
OpenIDE-Module-Specification-Version: 7.50
6
6
(-)a/openide.awt/src/org/openide/awt/ToolbarWithOverflow.java (+269 lines)
Line 0    Link Here 
1
/*
2
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3
 *
4
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
5
 *
6
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7
 * Other names may be trademarks of their respective owners.
8
 *
9
 * The contents of this file are subject to the terms of either the GNU
10
 * General Public License Version 2 only ("GPL") or the Common
11
 * Development and Distribution License("CDDL") (collectively, the
12
 * "License"). You may not use this file except in compliance with the
13
 * License. You can obtain a copy of the License at
14
 * http://www.netbeans.org/cddl-gplv2.html
15
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16
 * specific language governing permissions and limitations under the
17
 * License.  When distributing the software, include this License Header
18
 * Notice in each file and include the License file at
19
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
20
 * particular file as subject to the "Classpath" exception as provided
21
 * by Oracle in the GPL Version 2 section of the License file that
22
 * accompanied this code. If applicable, add the following below the
23
 * License Header, with the fields enclosed by brackets [] replaced by
24
 * your own identifying information:
25
 * "Portions Copyrighted [year] [name of copyright owner]"
26
 *
27
 * If you wish your version of this file to be governed by only the CDDL
28
 * or only the GPL Version 2, indicate your decision by adding
29
 * "[Contributor] elects to include this software in this distribution
30
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
31
 * single choice of license, a recipient has the option to distribute
32
 * your version of this file under either the CDDL, the GPL Version 2 or
33
 * to extend the choice of license to its licensees as provided above.
34
 * However, if you add GPL Version 2 code and therefore, elected the GPL
35
 * Version 2 license, then the option applies only if the new code is
36
 * made subject to such option by the copyright holder.
37
 *
38
 * Contributor(s):
39
 *
40
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
41
 */
42
package org.openide.awt;
43
44
import java.awt.Component;
45
import java.awt.Dimension;
46
import java.awt.event.ComponentAdapter;
47
import java.awt.event.ComponentEvent;
48
import java.awt.event.MouseAdapter;
49
import java.awt.event.MouseEvent;
50
import javax.swing.JButton;
51
import javax.swing.JComponent;
52
import javax.swing.JPopupMenu;
53
import javax.swing.JToolBar;
54
import org.openide.util.ImageUtilities;
55
56
/**
57
 * ToolbarWithOverflow provides a component which is useful for displaying commonly used
58
 * actions.  It adds an overflow button when the toolbar becomes too small to show all the
59
 * available actions.
60
 *
61
 * @author Th. Oikonomou
62
 * @since 7.50
63
 */
64
public class ToolbarWithOverflow extends JToolBar {
65
66
    private JButton overflowButton;
67
    private JPopupMenu popup;
68
    private JToolBar overflowToolbar;
69
    private int visibleButtons;
70
    private final String overflowIcon = "org/openide/awt/resources/overflow_right.png"; //NOI18N
71
    private final String PROP_PREF_ICON_SIZE = "PreferredIconSize"; //NOI18N
72
    private final String PROP_DRAGGER = "_toolbar_dragger_"; //NOI18N
73
74
    /**
75
     * Creates a new tool bar; orientation defaults to
76
     * <code>HORIZONTAL</code>.
77
     */
78
    public ToolbarWithOverflow() {
79
        this(HORIZONTAL);
80
    }
81
82
    /**
83
     * Creates a new tool bar with the specified
84
     * <code>orientation</code>. The
85
     * <code>orientation</code> must be either
86
     * <code>HORIZONTAL</code> or
87
     * <code>VERTICAL</code>.
88
     *
89
     * @param orientation the orientation desired
90
     */
91
    public ToolbarWithOverflow(int orientation) {
92
        this(null, orientation);
93
    }
94
95
    /**
96
     * Creates a new tool bar with the specified
97
     * <code>name</code>. The name is used as the title of the undocked tool
98
     * bar. The default orientation is
99
     * <code>HORIZONTAL</code>.
100
     *
101
     * @param name the name of the tool bar
102
     */
103
    public ToolbarWithOverflow(String name) {
104
        this(name, HORIZONTAL);
105
    }
106
107
    /**
108
     * Creates a new tool bar with a specified
109
     * <code>name</code> and
110
     * <code>orientation</code>. All other constructors call this constructor.
111
     * If
112
     * <code>orientation</code> is an invalid value, an exception will be
113
     * thrown.
114
     *
115
     * @param name the name of the tool bar
116
     * @param orientation the initial orientation -- it must be     *		either <code>HORIZONTAL</code> or <code>VERTICAL</code>
117
     * @exception IllegalArgumentException if orientation is neither
118
     * <code>HORIZONTAL</code> nor <code>VERTICAL</code>
119
     */
120
    public ToolbarWithOverflow(String name, int orientation) {
121
        super(name, orientation);
122
        overflowButton = new JButton(ImageUtilities.loadImageIcon(overflowIcon, false));
123
        popup = new JPopupMenu();
124
        overflowToolbar = new JToolBar("overflowToolbar", orientation == HORIZONTAL ? VERTICAL : HORIZONTAL);
125
        overflowToolbar.setFloatable(false);
126
        overflowButton.addMouseListener(new MouseAdapter() {
127
            @Override
128
            public void mouseClicked(MouseEvent e) {
129
                popup.show(overflowButton, 0, overflowButton.getHeight());
130
            }
131
        });
132
        addComponentListener(new ComponentAdapter() {
133
            @Override
134
            public void componentResized(ComponentEvent e) {
135
                maybeAddOverflow();
136
            }
137
        });
138
    }
139
    
140
    @Override
141
    public void removeAll() {
142
        super.removeAll();
143
        overflowToolbar.removeAll();
144
    }
145
    
146
    @Override
147
    public final Dimension getPreferredSize() {
148
        Component[] comps = getAllComponents();
149
        int width = 0;
150
        int height = 0;
151
        for (int i = 0; i < comps.length; i++) {
152
            Component comp = comps[i];
153
            width += getOrientation() == HORIZONTAL ? comp.getPreferredSize().width : comp.getPreferredSize().height;
154
            height = getOrientation() == HORIZONTAL ? comp.getPreferredSize().height : comp.getPreferredSize().width;
155
        }
156
        if(overflowToolbar.getComponentCount() > 0) {
157
            width += getOrientation() == HORIZONTAL ? overflowButton.getPreferredSize().width : overflowButton.getPreferredSize().height;
158
        }
159
        Dimension dim = getOrientation() == HORIZONTAL ? new Dimension(width, height) : new Dimension(height, width);
160
        return dim;        
161
    }
162
163
    /**
164
     * Determines if an overflow button should be added to or removed from the toolbar.
165
     */
166
    private void maybeAddOverflow() {
167
        computeVisibleButtons();
168
        if (visibleButtons == -1) {
169
            handleOverflowRemoval();
170
        } else {
171
            handleOverflowAddittion();
172
        }
173
        validate();
174
        repaint();
175
    }
176
177
    private void computeVisibleButtons() {
178
        handleIconResize();
179
        Component[] comps = getAllComponents();
180
        int sizeSoFar = 0;
181
        int maxSize = getOrientation() == HORIZONTAL ? getWidth() : getHeight();
182
        int overflowButtonSize = getOrientation() == HORIZONTAL ? overflowButton.getPreferredSize().width : overflowButton.getPreferredSize().height;
183
        for (int i = 0; i < comps.length; i++) {
184
            Component comp = comps[i];
185
            sizeSoFar += getOrientation() == HORIZONTAL ? comp.getPreferredSize().width : comp.getPreferredSize().height;
186
            if (sizeSoFar > maxSize) {
187
                visibleButtons = i;
188
                break;
189
            } else {
190
                if (sizeSoFar + overflowButtonSize > maxSize && i + 1 != comps.length) {
191
                    visibleButtons = i;
192
                    break;
193
                } else {
194
                    visibleButtons = i + 1;
195
                }
196
            }
197
        }
198
        if(visibleButtons == 0 && comps.length > 0) {            
199
            if (comps[0] instanceof JComponent) {
200
                if (Boolean.TRUE.equals(((JComponent) comps[0]).getClientProperty(PROP_DRAGGER))) {
201
                    visibleButtons = 1;
202
                }
203
            }
204
        }
205
        if (visibleButtons == comps.length) {
206
            visibleButtons = -1;
207
        }
208
    }
209
210
    private void handleOverflowAddittion() {
211
        Component[] comps = getAllComponents();
212
        if (visibleButtons <= comps.length) {
213
            removeAll();
214
            overflowToolbar.setOrientation(getOrientation() == HORIZONTAL ? VERTICAL : HORIZONTAL);
215
            popup.removeAll();
216
217
            for (int i = 0; i < visibleButtons; i++) {
218
                add(comps[i]);
219
            }
220
            for (int i = visibleButtons; i < comps.length; i++) {
221
                overflowToolbar.add(comps[i]);
222
            }
223
            popup.add(overflowToolbar);
224
            add(overflowButton);
225
        }
226
    }
227
228
    private void handleOverflowRemoval() {
229
        if (overflowToolbar.getComponents().length > 0) {
230
            remove(overflowButton);
231
            handleIconResize();
232
            for (Component comp : overflowToolbar.getComponents()) {
233
                add(comp);
234
            }
235
            overflowToolbar.removeAll();
236
            popup.removeAll();
237
        }
238
    }
239
240
    private void handleIconResize() {
241
        for (Component comp : overflowToolbar.getComponents()) {
242
            boolean smallToolbarIcons = getClientProperty(PROP_PREF_ICON_SIZE) == null;
243
            if (smallToolbarIcons) {
244
                ((JComponent) comp).putClientProperty(PROP_PREF_ICON_SIZE, null);
245
            } else {
246
                ((JComponent) comp).putClientProperty(PROP_PREF_ICON_SIZE, Integer.valueOf(24));
247
            }
248
        }
249
    }
250
251
    private Component[] getAllComponents() {
252
        Component[] toolbarComps;
253
        Component[] overflowComps = overflowToolbar.getComponents();
254
        if (overflowComps.length == 0) {
255
            toolbarComps = getComponents();
256
        } else {
257
            if (getComponentCount() > 0) {
258
                toolbarComps = new Component[getComponents().length - 1];
259
                System.arraycopy(getComponents(), 0, toolbarComps, 0, toolbarComps.length);
260
            } else {
261
                toolbarComps = new Component[0];
262
            }
263
        }
264
        Component[] comps = new Component[toolbarComps.length + overflowComps.length];
265
        System.arraycopy(toolbarComps, 0, comps, 0, toolbarComps.length);
266
        System.arraycopy(overflowComps, 0, comps, toolbarComps.length, overflowComps.length);
267
        return comps;
268
    }
269
}
(-)a/openide.loaders/src/org/openide/awt/Toolbar.java (-1 / +1 lines)
 Lines 79-85    Link Here 
79
 *
79
 *
80
 * @author  David Peroutka, Libor Kramolis
80
 * @author  David Peroutka, Libor Kramolis
81
 */
81
 */
82
public class Toolbar extends JToolBar /*implemented by patchsuperclass MouseInputListener*/ {
82
public class Toolbar extends ToolbarWithOverflow /*implemented by patchsuperclass MouseInputListener*/ {
83
    /** Basic toolbar height.
83
    /** Basic toolbar height.
84
     @deprecated Use getBasicHeight instead. */
84
     @deprecated Use getBasicHeight instead. */
85
    @Deprecated
85
    @Deprecated

Return to bug 216175
By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2014, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo