| /* |
| * Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.swing; |
| |
| import static sun.swing.SwingUtilities2.BASICMENUITEMUI_MAX_TEXT_OFFSET; |
| |
| import javax.swing.*; |
| import javax.swing.plaf.basic.BasicHTML; |
| import javax.swing.text.View; |
| import java.awt.*; |
| import java.awt.event.KeyEvent; |
| import java.util.Map; |
| import java.util.HashMap; |
| |
| /** |
| * Calculates preferred size and layouts menu items. |
| */ |
| public class MenuItemLayoutHelper { |
| |
| /* Client Property keys for calculation of maximal widths */ |
| public static final StringUIClientPropertyKey MAX_ARROW_WIDTH = |
| new StringUIClientPropertyKey("maxArrowWidth"); |
| public static final StringUIClientPropertyKey MAX_CHECK_WIDTH = |
| new StringUIClientPropertyKey("maxCheckWidth"); |
| public static final StringUIClientPropertyKey MAX_ICON_WIDTH = |
| new StringUIClientPropertyKey("maxIconWidth"); |
| public static final StringUIClientPropertyKey MAX_TEXT_WIDTH = |
| new StringUIClientPropertyKey("maxTextWidth"); |
| public static final StringUIClientPropertyKey MAX_ACC_WIDTH = |
| new StringUIClientPropertyKey("maxAccWidth"); |
| public static final StringUIClientPropertyKey MAX_LABEL_WIDTH = |
| new StringUIClientPropertyKey("maxLabelWidth"); |
| |
| private JMenuItem mi; |
| private JComponent miParent; |
| |
| private Font font; |
| private Font accFont; |
| private FontMetrics fm; |
| private FontMetrics accFm; |
| |
| private Icon icon; |
| private Icon checkIcon; |
| private Icon arrowIcon; |
| private String text; |
| private String accText; |
| |
| private boolean isColumnLayout; |
| private boolean useCheckAndArrow; |
| private boolean isLeftToRight; |
| private boolean isTopLevelMenu; |
| private View htmlView; |
| |
| private int verticalAlignment; |
| private int horizontalAlignment; |
| private int verticalTextPosition; |
| private int horizontalTextPosition; |
| private int gap; |
| private int leadingGap; |
| private int afterCheckIconGap; |
| private int minTextOffset; |
| |
| private int leftTextExtraWidth; |
| |
| private Rectangle viewRect; |
| |
| private RectSize iconSize; |
| private RectSize textSize; |
| private RectSize accSize; |
| private RectSize checkSize; |
| private RectSize arrowSize; |
| private RectSize labelSize; |
| |
| /** |
| * The empty protected constructor is necessary for derived classes. |
| */ |
| protected MenuItemLayoutHelper() { |
| } |
| |
| public MenuItemLayoutHelper(JMenuItem mi, Icon checkIcon, Icon arrowIcon, |
| Rectangle viewRect, int gap, String accDelimiter, |
| boolean isLeftToRight, Font font, Font accFont, |
| boolean useCheckAndArrow, String propertyPrefix) { |
| reset(mi, checkIcon, arrowIcon, viewRect, gap, accDelimiter, |
| isLeftToRight, font, accFont, useCheckAndArrow, propertyPrefix); |
| } |
| |
| protected void reset(JMenuItem mi, Icon checkIcon, Icon arrowIcon, |
| Rectangle viewRect, int gap, String accDelimiter, |
| boolean isLeftToRight, Font font, Font accFont, |
| boolean useCheckAndArrow, String propertyPrefix) { |
| this.mi = mi; |
| this.miParent = getMenuItemParent(mi); |
| this.accText = getAccText(accDelimiter); |
| this.verticalAlignment = mi.getVerticalAlignment(); |
| this.horizontalAlignment = mi.getHorizontalAlignment(); |
| this.verticalTextPosition = mi.getVerticalTextPosition(); |
| this.horizontalTextPosition = mi.getHorizontalTextPosition(); |
| this.useCheckAndArrow = useCheckAndArrow; |
| this.font = font; |
| this.accFont = accFont; |
| this.fm = mi.getFontMetrics(font); |
| this.accFm = mi.getFontMetrics(accFont); |
| this.isLeftToRight = isLeftToRight; |
| this.isColumnLayout = isColumnLayout(isLeftToRight, |
| horizontalAlignment, horizontalTextPosition, |
| verticalTextPosition); |
| this.isTopLevelMenu = (this.miParent == null) ? true : false; |
| this.checkIcon = checkIcon; |
| this.icon = getIcon(propertyPrefix); |
| this.arrowIcon = arrowIcon; |
| this.text = mi.getText(); |
| this.gap = gap; |
| this.afterCheckIconGap = getAfterCheckIconGap(propertyPrefix); |
| this.minTextOffset = getMinTextOffset(propertyPrefix); |
| this.htmlView = (View) mi.getClientProperty(BasicHTML.propertyKey); |
| this.viewRect = viewRect; |
| |
| this.iconSize = new RectSize(); |
| this.textSize = new RectSize(); |
| this.accSize = new RectSize(); |
| this.checkSize = new RectSize(); |
| this.arrowSize = new RectSize(); |
| this.labelSize = new RectSize(); |
| calcExtraWidths(); |
| calcWidthsAndHeights(); |
| setOriginalWidths(); |
| calcMaxWidths(); |
| |
| this.leadingGap = getLeadingGap(propertyPrefix); |
| calcMaxTextOffset(viewRect); |
| } |
| |
| private void calcExtraWidths() { |
| leftTextExtraWidth = getLeftExtraWidth(text); |
| } |
| |
| private int getLeftExtraWidth(String str) { |
| int lsb = SwingUtilities2.getLeftSideBearing(mi, fm, str); |
| if (lsb < 0) { |
| return -lsb; |
| } else { |
| return 0; |
| } |
| } |
| |
| private void setOriginalWidths() { |
| iconSize.origWidth = iconSize.width; |
| textSize.origWidth = textSize.width; |
| accSize.origWidth = accSize.width; |
| checkSize.origWidth = checkSize.width; |
| arrowSize.origWidth = arrowSize.width; |
| } |
| |
| private String getAccText(String acceleratorDelimiter) { |
| String accText = ""; |
| KeyStroke accelerator = mi.getAccelerator(); |
| if (accelerator != null) { |
| int modifiers = accelerator.getModifiers(); |
| if (modifiers > 0) { |
| accText = KeyEvent.getKeyModifiersText(modifiers); |
| accText += acceleratorDelimiter; |
| } |
| int keyCode = accelerator.getKeyCode(); |
| if (keyCode != 0) { |
| accText += KeyEvent.getKeyText(keyCode); |
| } else { |
| accText += accelerator.getKeyChar(); |
| } |
| } |
| return accText; |
| } |
| |
| private Icon getIcon(String propertyPrefix) { |
| // In case of column layout, .checkIconFactory is defined for this UI, |
| // the icon is compatible with it and useCheckAndArrow() is true, |
| // then the icon is handled by the checkIcon. |
| Icon icon = null; |
| MenuItemCheckIconFactory iconFactory = |
| (MenuItemCheckIconFactory) UIManager.get(propertyPrefix |
| + ".checkIconFactory"); |
| if (!isColumnLayout || !useCheckAndArrow || iconFactory == null |
| || !iconFactory.isCompatible(checkIcon, propertyPrefix)) { |
| icon = mi.getIcon(); |
| } |
| return icon; |
| } |
| |
| private int getMinTextOffset(String propertyPrefix) { |
| int minimumTextOffset = 0; |
| Object minimumTextOffsetObject = |
| UIManager.get(propertyPrefix + ".minimumTextOffset"); |
| if (minimumTextOffsetObject instanceof Integer) { |
| minimumTextOffset = (Integer) minimumTextOffsetObject; |
| } |
| return minimumTextOffset; |
| } |
| |
| private int getAfterCheckIconGap(String propertyPrefix) { |
| int afterCheckIconGap = gap; |
| Object afterCheckIconGapObject = |
| UIManager.get(propertyPrefix + ".afterCheckIconGap"); |
| if (afterCheckIconGapObject instanceof Integer) { |
| afterCheckIconGap = (Integer) afterCheckIconGapObject; |
| } |
| return afterCheckIconGap; |
| } |
| |
| private int getLeadingGap(String propertyPrefix) { |
| if (checkSize.getMaxWidth() > 0) { |
| return getCheckOffset(propertyPrefix); |
| } else { |
| return gap; // There is no any check icon |
| } |
| } |
| |
| private int getCheckOffset(String propertyPrefix) { |
| int checkIconOffset = gap; |
| Object checkIconOffsetObject = |
| UIManager.get(propertyPrefix + ".checkIconOffset"); |
| if (checkIconOffsetObject instanceof Integer) { |
| checkIconOffset = (Integer) checkIconOffsetObject; |
| } |
| return checkIconOffset; |
| } |
| |
| protected void calcWidthsAndHeights() { |
| // iconRect |
| if (icon != null) { |
| iconSize.width = icon.getIconWidth(); |
| iconSize.height = icon.getIconHeight(); |
| } |
| |
| // accRect |
| if (!accText.equals("")) { |
| accSize.width = SwingUtilities2.stringWidth(mi, accFm, accText); |
| accSize.height = accFm.getHeight(); |
| } |
| |
| // textRect |
| if (text == null) { |
| text = ""; |
| } else if (!text.equals("")) { |
| if (htmlView != null) { |
| // Text is HTML |
| textSize.width = |
| (int) htmlView.getPreferredSpan(View.X_AXIS); |
| textSize.height = |
| (int) htmlView.getPreferredSpan(View.Y_AXIS); |
| } else { |
| // Text isn't HTML |
| textSize.width = SwingUtilities2.stringWidth(mi, fm, text); |
| textSize.height = fm.getHeight(); |
| } |
| } |
| |
| if (useCheckAndArrow) { |
| // checkIcon |
| if (checkIcon != null) { |
| checkSize.width = checkIcon.getIconWidth(); |
| checkSize.height = checkIcon.getIconHeight(); |
| } |
| // arrowRect |
| if (arrowIcon != null) { |
| arrowSize.width = arrowIcon.getIconWidth(); |
| arrowSize.height = arrowIcon.getIconHeight(); |
| } |
| } |
| |
| // labelRect |
| if (isColumnLayout) { |
| labelSize.width = iconSize.width + textSize.width + gap; |
| labelSize.height = max(checkSize.height, iconSize.height, |
| textSize.height, accSize.height, arrowSize.height); |
| } else { |
| Rectangle textRect = new Rectangle(); |
| Rectangle iconRect = new Rectangle(); |
| SwingUtilities.layoutCompoundLabel(mi, fm, text, icon, |
| verticalAlignment, horizontalAlignment, |
| verticalTextPosition, horizontalTextPosition, |
| viewRect, iconRect, textRect, gap); |
| textRect.width += leftTextExtraWidth; |
| Rectangle labelRect = iconRect.union(textRect); |
| labelSize.height = labelRect.height; |
| labelSize.width = labelRect.width; |
| } |
| } |
| |
| protected void calcMaxWidths() { |
| calcMaxWidth(checkSize, MAX_CHECK_WIDTH); |
| calcMaxWidth(arrowSize, MAX_ARROW_WIDTH); |
| calcMaxWidth(accSize, MAX_ACC_WIDTH); |
| |
| if (isColumnLayout) { |
| calcMaxWidth(iconSize, MAX_ICON_WIDTH); |
| calcMaxWidth(textSize, MAX_TEXT_WIDTH); |
| int curGap = gap; |
| if ((iconSize.getMaxWidth() == 0) |
| || (textSize.getMaxWidth() == 0)) { |
| curGap = 0; |
| } |
| labelSize.maxWidth = |
| calcMaxValue(MAX_LABEL_WIDTH, iconSize.maxWidth |
| + textSize.maxWidth + curGap); |
| } else { |
| // We shouldn't use current icon and text widths |
| // in maximal widths calculation for complex layout. |
| iconSize.maxWidth = getParentIntProperty(MAX_ICON_WIDTH); |
| calcMaxWidth(labelSize, MAX_LABEL_WIDTH); |
| // If maxLabelWidth is wider |
| // than the widest icon + the widest text + gap, |
| // we should update the maximal text witdh |
| int candidateTextWidth = labelSize.maxWidth - iconSize.maxWidth; |
| if (iconSize.maxWidth > 0) { |
| candidateTextWidth -= gap; |
| } |
| textSize.maxWidth = calcMaxValue(MAX_TEXT_WIDTH, candidateTextWidth); |
| } |
| } |
| |
| protected void calcMaxWidth(RectSize rs, Object key) { |
| rs.maxWidth = calcMaxValue(key, rs.width); |
| } |
| |
| /** |
| * Calculates and returns maximal value through specified parent component |
| * client property. |
| * |
| * @param propertyName name of the property, which stores the maximal value. |
| * @param value a value which pretends to be maximal |
| * @return maximal value among the parent property and the value. |
| */ |
| protected int calcMaxValue(Object propertyName, int value) { |
| // Get maximal value from parent client property |
| int maxValue = getParentIntProperty(propertyName); |
| // Store new maximal width in parent client property |
| if (value > maxValue) { |
| if (miParent != null) { |
| miParent.putClientProperty(propertyName, value); |
| } |
| return value; |
| } else { |
| return maxValue; |
| } |
| } |
| |
| /** |
| * Returns parent client property as int. |
| * @param propertyName name of the parent property. |
| * @return value of the property as int. |
| */ |
| protected int getParentIntProperty(Object propertyName) { |
| Object value = null; |
| if (miParent != null) { |
| value = miParent.getClientProperty(propertyName); |
| } |
| if ((value == null) || !(value instanceof Integer)) { |
| value = 0; |
| } |
| return (Integer) value; |
| } |
| |
| public static boolean isColumnLayout(boolean isLeftToRight, |
| JMenuItem mi) { |
| assert(mi != null); |
| return isColumnLayout(isLeftToRight, mi.getHorizontalAlignment(), |
| mi.getHorizontalTextPosition(), mi.getVerticalTextPosition()); |
| } |
| |
| /** |
| * Answers should we do column layout for a menu item or not. |
| * We do it when a user doesn't set any alignments |
| * and text positions manually, except the vertical alignment. |
| */ |
| public static boolean isColumnLayout(boolean isLeftToRight, |
| int horizontalAlignment, |
| int horizontalTextPosition, |
| int verticalTextPosition) { |
| if (verticalTextPosition != SwingConstants.CENTER) { |
| return false; |
| } |
| if (isLeftToRight) { |
| if (horizontalAlignment != SwingConstants.LEADING |
| && horizontalAlignment != SwingConstants.LEFT) { |
| return false; |
| } |
| if (horizontalTextPosition != SwingConstants.TRAILING |
| && horizontalTextPosition != SwingConstants.RIGHT) { |
| return false; |
| } |
| } else { |
| if (horizontalAlignment != SwingConstants.LEADING |
| && horizontalAlignment != SwingConstants.RIGHT) { |
| return false; |
| } |
| if (horizontalTextPosition != SwingConstants.TRAILING |
| && horizontalTextPosition != SwingConstants.LEFT) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Calculates maximal text offset. |
| * It is required for some L&Fs (ex: Vista L&F). |
| * The offset is meaningful only for L2R column layout. |
| * |
| * @param viewRect the rectangle, the maximal text offset |
| * will be calculated for. |
| */ |
| private void calcMaxTextOffset(Rectangle viewRect) { |
| if (!isColumnLayout || !isLeftToRight) { |
| return; |
| } |
| |
| // Calculate the current text offset |
| int offset = viewRect.x + leadingGap + checkSize.maxWidth |
| + afterCheckIconGap + iconSize.maxWidth + gap; |
| if (checkSize.maxWidth == 0) { |
| offset -= afterCheckIconGap; |
| } |
| if (iconSize.maxWidth == 0) { |
| offset -= gap; |
| } |
| |
| // maximal text offset shouldn't be less than minimal text offset; |
| if (offset < minTextOffset) { |
| offset = minTextOffset; |
| } |
| |
| // Calculate and store the maximal text offset |
| calcMaxValue(SwingUtilities2.BASICMENUITEMUI_MAX_TEXT_OFFSET, offset); |
| } |
| |
| /** |
| * Layout icon, text, check icon, accelerator text and arrow icon |
| * in the viewRect and return their positions. |
| * |
| * If horizontalAlignment, verticalTextPosition and horizontalTextPosition |
| * are default (user doesn't set any manually) the layouting algorithm is: |
| * Elements are layouted in the five columns: |
| * check icon + icon + text + accelerator text + arrow icon |
| * |
| * In the other case elements are layouted in the four columns: |
| * check icon + label + accelerator text + arrow icon |
| * Label is union of icon and text. |
| * |
| * The order of columns can be reversed. |
| * It depends on the menu item orientation. |
| */ |
| public LayoutResult layoutMenuItem() { |
| LayoutResult lr = createLayoutResult(); |
| prepareForLayout(lr); |
| |
| if (isColumnLayout()) { |
| if (isLeftToRight()) { |
| doLTRColumnLayout(lr, getLTRColumnAlignment()); |
| } else { |
| doRTLColumnLayout(lr, getRTLColumnAlignment()); |
| } |
| } else { |
| if (isLeftToRight()) { |
| doLTRComplexLayout(lr, getLTRColumnAlignment()); |
| } else { |
| doRTLComplexLayout(lr, getRTLColumnAlignment()); |
| } |
| } |
| |
| alignAccCheckAndArrowVertically(lr); |
| return lr; |
| } |
| |
| private LayoutResult createLayoutResult() { |
| return new LayoutResult( |
| new Rectangle(iconSize.width, iconSize.height), |
| new Rectangle(textSize.width, textSize.height), |
| new Rectangle(accSize.width, accSize.height), |
| new Rectangle(checkSize.width, checkSize.height), |
| new Rectangle(arrowSize.width, arrowSize.height), |
| new Rectangle(labelSize.width, labelSize.height) |
| ); |
| } |
| |
| public ColumnAlignment getLTRColumnAlignment() { |
| return ColumnAlignment.LEFT_ALIGNMENT; |
| } |
| |
| public ColumnAlignment getRTLColumnAlignment() { |
| return ColumnAlignment.RIGHT_ALIGNMENT; |
| } |
| |
| protected void prepareForLayout(LayoutResult lr) { |
| lr.checkRect.width = checkSize.maxWidth; |
| lr.accRect.width = accSize.maxWidth; |
| lr.arrowRect.width = arrowSize.maxWidth; |
| } |
| |
| /** |
| * Aligns the accelertor text and the check and arrow icons vertically |
| * with the center of the label rect. |
| */ |
| private void alignAccCheckAndArrowVertically(LayoutResult lr) { |
| lr.accRect.y = (int)(lr.labelRect.y |
| + (float)lr.labelRect.height/2 |
| - (float)lr.accRect.height/2); |
| fixVerticalAlignment(lr, lr.accRect); |
| if (useCheckAndArrow) { |
| lr.arrowRect.y = (int)(lr.labelRect.y |
| + (float)lr.labelRect.height/2 |
| - (float)lr.arrowRect.height/2); |
| lr.checkRect.y = (int)(lr.labelRect.y |
| + (float)lr.labelRect.height/2 |
| - (float)lr.checkRect.height/2); |
| fixVerticalAlignment(lr, lr.arrowRect); |
| fixVerticalAlignment(lr, lr.checkRect); |
| } |
| } |
| |
| /** |
| * Fixes vertical alignment of all menu item elements if rect.y |
| * or (rect.y + rect.height) is out of viewRect bounds |
| */ |
| private void fixVerticalAlignment(LayoutResult lr, Rectangle r) { |
| int delta = 0; |
| if (r.y < viewRect.y) { |
| delta = viewRect.y - r.y; |
| } else if (r.y + r.height > viewRect.y + viewRect.height) { |
| delta = viewRect.y + viewRect.height - r.y - r.height; |
| } |
| if (delta != 0) { |
| lr.checkRect.y += delta; |
| lr.iconRect.y += delta; |
| lr.textRect.y += delta; |
| lr.accRect.y += delta; |
| lr.arrowRect.y += delta; |
| lr.labelRect.y += delta; |
| } |
| } |
| |
| private void doLTRColumnLayout(LayoutResult lr, ColumnAlignment alignment) { |
| // Set maximal width for all the five basic rects |
| // (three other ones are already maximal) |
| lr.iconRect.width = iconSize.maxWidth; |
| lr.textRect.width = textSize.maxWidth; |
| |
| // Set X coordinates |
| // All rects will be aligned at the left side |
| calcXPositionsLTR(viewRect.x, leadingGap, gap, lr.checkRect, |
| lr.iconRect, lr.textRect); |
| |
| // Tune afterCheckIconGap |
| if (lr.checkRect.width > 0) { // there is the afterCheckIconGap |
| lr.iconRect.x += afterCheckIconGap - gap; |
| lr.textRect.x += afterCheckIconGap - gap; |
| } |
| |
| calcXPositionsRTL(viewRect.x + viewRect.width, leadingGap, gap, |
| lr.arrowRect, lr.accRect); |
| |
| // Take into account minimal text offset |
| int textOffset = lr.textRect.x - viewRect.x; |
| if (!isTopLevelMenu && (textOffset < minTextOffset)) { |
| lr.textRect.x += minTextOffset - textOffset; |
| } |
| |
| alignRects(lr, alignment); |
| |
| // Set Y coordinate for text and icon. |
| // Y coordinates for other rects |
| // will be calculated later in layoutMenuItem. |
| calcTextAndIconYPositions(lr); |
| |
| // Calculate valid X and Y coordinates for labelRect |
| lr.setLabelRect(lr.textRect.union(lr.iconRect)); |
| } |
| |
| private void doLTRComplexLayout(LayoutResult lr, ColumnAlignment alignment) { |
| lr.labelRect.width = labelSize.maxWidth; |
| |
| // Set X coordinates |
| calcXPositionsLTR(viewRect.x, leadingGap, gap, lr.checkRect, |
| lr.labelRect); |
| |
| // Tune afterCheckIconGap |
| if (lr.checkRect.width > 0) { // there is the afterCheckIconGap |
| lr.labelRect.x += afterCheckIconGap - gap; |
| } |
| |
| calcXPositionsRTL(viewRect.x + viewRect.width, |
| leadingGap, gap, lr.arrowRect, lr.accRect); |
| |
| // Take into account minimal text offset |
| int labelOffset = lr.labelRect.x - viewRect.x; |
| if (!isTopLevelMenu && (labelOffset < minTextOffset)) { |
| lr.labelRect.x += minTextOffset - labelOffset; |
| } |
| |
| alignRects(lr, alignment); |
| |
| // Center labelRect vertically |
| calcLabelYPosition(lr); |
| |
| layoutIconAndTextInLabelRect(lr); |
| } |
| |
| private void doRTLColumnLayout(LayoutResult lr, ColumnAlignment alignment) { |
| // Set maximal width for all the five basic rects |
| // (three other ones are already maximal) |
| lr.iconRect.width = iconSize.maxWidth; |
| lr.textRect.width = textSize.maxWidth; |
| |
| // Set X coordinates |
| calcXPositionsRTL(viewRect.x + viewRect.width, leadingGap, gap, |
| lr.checkRect, lr.iconRect, lr.textRect); |
| |
| // Tune the gap after check icon |
| if (lr.checkRect.width > 0) { // there is the gap after check icon |
| lr.iconRect.x -= afterCheckIconGap - gap; |
| lr.textRect.x -= afterCheckIconGap - gap; |
| } |
| |
| calcXPositionsLTR(viewRect.x, leadingGap, gap, lr.arrowRect, |
| lr.accRect); |
| |
| // Take into account minimal text offset |
| int textOffset = (viewRect.x + viewRect.width) |
| - (lr.textRect.x + lr.textRect.width); |
| if (!isTopLevelMenu && (textOffset < minTextOffset)) { |
| lr.textRect.x -= minTextOffset - textOffset; |
| } |
| |
| alignRects(lr, alignment); |
| |
| // Set Y coordinates for text and icon. |
| // Y coordinates for other rects |
| // will be calculated later in layoutMenuItem. |
| calcTextAndIconYPositions(lr); |
| |
| // Calculate valid X and Y coordinate for labelRect |
| lr.setLabelRect(lr.textRect.union(lr.iconRect)); |
| } |
| |
| private void doRTLComplexLayout(LayoutResult lr, ColumnAlignment alignment) { |
| lr.labelRect.width = labelSize.maxWidth; |
| |
| // Set X coordinates |
| calcXPositionsRTL(viewRect.x + viewRect.width, leadingGap, gap, |
| lr.checkRect, lr.labelRect); |
| |
| // Tune the gap after check icon |
| if (lr.checkRect.width > 0) { // there is the gap after check icon |
| lr.labelRect.x -= afterCheckIconGap - gap; |
| } |
| |
| calcXPositionsLTR(viewRect.x, leadingGap, gap, lr.arrowRect, lr.accRect); |
| |
| // Take into account minimal text offset |
| int labelOffset = (viewRect.x + viewRect.width) |
| - (lr.labelRect.x + lr.labelRect.width); |
| if (!isTopLevelMenu && (labelOffset < minTextOffset)) { |
| lr.labelRect.x -= minTextOffset - labelOffset; |
| } |
| |
| alignRects(lr, alignment); |
| |
| // Center labelRect vertically |
| calcLabelYPosition(lr); |
| |
| layoutIconAndTextInLabelRect(lr); |
| } |
| |
| private void alignRects(LayoutResult lr, ColumnAlignment alignment) { |
| alignRect(lr.checkRect, alignment.getCheckAlignment(), |
| checkSize.getOrigWidth()); |
| alignRect(lr.iconRect, alignment.getIconAlignment(), |
| iconSize.getOrigWidth()); |
| alignRect(lr.textRect, alignment.getTextAlignment(), |
| textSize.getOrigWidth()); |
| alignRect(lr.accRect, alignment.getAccAlignment(), |
| accSize.getOrigWidth()); |
| alignRect(lr.arrowRect, alignment.getArrowAlignment(), |
| arrowSize.getOrigWidth()); |
| } |
| |
| private void alignRect(Rectangle rect, int alignment, int origWidth) { |
| if (alignment == SwingConstants.RIGHT) { |
| rect.x = rect.x + rect.width - origWidth; |
| } |
| rect.width = origWidth; |
| } |
| |
| protected void layoutIconAndTextInLabelRect(LayoutResult lr) { |
| lr.setTextRect(new Rectangle()); |
| lr.setIconRect(new Rectangle()); |
| SwingUtilities.layoutCompoundLabel( |
| mi, fm, text,icon, verticalAlignment, horizontalAlignment, |
| verticalTextPosition, horizontalTextPosition, lr.labelRect, |
| lr.iconRect, lr.textRect, gap); |
| } |
| |
| private void calcXPositionsLTR(int startXPos, int leadingGap, |
| int gap, Rectangle... rects) { |
| int curXPos = startXPos + leadingGap; |
| for (Rectangle rect : rects) { |
| rect.x = curXPos; |
| if (rect.width > 0) { |
| curXPos += rect.width + gap; |
| } |
| } |
| } |
| |
| private void calcXPositionsRTL(int startXPos, int leadingGap, |
| int gap, Rectangle... rects) { |
| int curXPos = startXPos - leadingGap; |
| for (Rectangle rect : rects) { |
| rect.x = curXPos - rect.width; |
| if (rect.width > 0) { |
| curXPos -= rect.width + gap; |
| } |
| } |
| } |
| |
| /** |
| * Sets Y coordinates of text and icon |
| * taking into account the vertical alignment |
| */ |
| private void calcTextAndIconYPositions(LayoutResult lr) { |
| if (verticalAlignment == SwingUtilities.TOP) { |
| lr.textRect.y = (int)(viewRect.y |
| + (float)lr.labelRect.height/2 |
| - (float)lr.textRect.height/2); |
| lr.iconRect.y = (int)(viewRect.y |
| + (float)lr.labelRect.height/2 |
| - (float)lr.iconRect.height/2); |
| } else if (verticalAlignment == SwingUtilities.CENTER) { |
| lr.textRect.y = (int)(viewRect.y |
| + (float)viewRect.height/2 |
| - (float)lr.textRect.height/2); |
| lr.iconRect.y = (int)(viewRect.y |
| + (float)viewRect.height/2 |
| - (float)lr.iconRect.height/2); |
| } |
| else if (verticalAlignment == SwingUtilities.BOTTOM) { |
| lr.textRect.y = (int)(viewRect.y |
| + viewRect.height |
| - (float)lr.labelRect.height/2 |
| - (float)lr.textRect.height/2); |
| lr.iconRect.y = (int)(viewRect.y |
| + viewRect.height |
| - (float)lr.labelRect.height/2 |
| - (float)lr.iconRect.height/2); |
| } |
| } |
| |
| /** |
| * Sets labelRect Y coordinate |
| * taking into account the vertical alignment |
| */ |
| private void calcLabelYPosition(LayoutResult lr) { |
| if (verticalAlignment == SwingUtilities.TOP) { |
| lr.labelRect.y = viewRect.y; |
| } else if (verticalAlignment == SwingUtilities.CENTER) { |
| lr.labelRect.y = (int)(viewRect.y |
| + (float)viewRect.height/2 |
| - (float)lr.labelRect.height/2); |
| } else if (verticalAlignment == SwingUtilities.BOTTOM) { |
| lr.labelRect.y = viewRect.y + viewRect.height |
| - lr.labelRect.height; |
| } |
| } |
| |
| /** |
| * Returns parent of this component if it is not a top-level menu |
| * Otherwise returns null. |
| * @param menuItem the menu item whose parent will be returned. |
| * @return parent of this component if it is not a top-level menu |
| * Otherwise returns null. |
| */ |
| public static JComponent getMenuItemParent(JMenuItem menuItem) { |
| Container parent = menuItem.getParent(); |
| if ((parent instanceof JComponent) && |
| (!(menuItem instanceof JMenu) || |
| !((JMenu)menuItem).isTopLevelMenu())) { |
| return (JComponent) parent; |
| } else { |
| return null; |
| } |
| } |
| |
| public static void clearUsedParentClientProperties(JMenuItem menuItem) { |
| clearUsedClientProperties(getMenuItemParent(menuItem)); |
| } |
| |
| public static void clearUsedClientProperties(JComponent c) { |
| if (c != null) { |
| c.putClientProperty(MAX_ARROW_WIDTH, null); |
| c.putClientProperty(MAX_CHECK_WIDTH, null); |
| c.putClientProperty(MAX_ACC_WIDTH, null); |
| c.putClientProperty(MAX_TEXT_WIDTH, null); |
| c.putClientProperty(MAX_ICON_WIDTH, null); |
| c.putClientProperty(MAX_LABEL_WIDTH, null); |
| c.putClientProperty(BASICMENUITEMUI_MAX_TEXT_OFFSET, null); |
| } |
| } |
| |
| /** |
| * Finds and returns maximal integer value in the given array. |
| * @param values array where the search will be performed. |
| * @return maximal vaule. |
| */ |
| public static int max(int... values) { |
| int maxValue = Integer.MIN_VALUE; |
| for (int i : values) { |
| if (i > maxValue) { |
| maxValue = i; |
| } |
| } |
| return maxValue; |
| } |
| |
| public static Rectangle createMaxRect() { |
| return new Rectangle(0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE); |
| } |
| |
| public static void addMaxWidth(RectSize size, int gap, Dimension result) { |
| if (size.maxWidth > 0) { |
| result.width += size.maxWidth + gap; |
| } |
| } |
| |
| public static void addWidth(int width, int gap, Dimension result) { |
| if (width > 0) { |
| result.width += width + gap; |
| } |
| } |
| |
| public JMenuItem getMenuItem() { |
| return mi; |
| } |
| |
| public JComponent getMenuItemParent() { |
| return miParent; |
| } |
| |
| public Font getFont() { |
| return font; |
| } |
| |
| public Font getAccFont() { |
| return accFont; |
| } |
| |
| public FontMetrics getFontMetrics() { |
| return fm; |
| } |
| |
| public FontMetrics getAccFontMetrics() { |
| return accFm; |
| } |
| |
| public Icon getIcon() { |
| return icon; |
| } |
| |
| public Icon getCheckIcon() { |
| return checkIcon; |
| } |
| |
| public Icon getArrowIcon() { |
| return arrowIcon; |
| } |
| |
| public String getText() { |
| return text; |
| } |
| |
| public String getAccText() { |
| return accText; |
| } |
| |
| public boolean isColumnLayout() { |
| return isColumnLayout; |
| } |
| |
| public boolean useCheckAndArrow() { |
| return useCheckAndArrow; |
| } |
| |
| public boolean isLeftToRight() { |
| return isLeftToRight; |
| } |
| |
| public boolean isTopLevelMenu() { |
| return isTopLevelMenu; |
| } |
| |
| public View getHtmlView() { |
| return htmlView; |
| } |
| |
| public int getVerticalAlignment() { |
| return verticalAlignment; |
| } |
| |
| public int getHorizontalAlignment() { |
| return horizontalAlignment; |
| } |
| |
| public int getVerticalTextPosition() { |
| return verticalTextPosition; |
| } |
| |
| public int getHorizontalTextPosition() { |
| return horizontalTextPosition; |
| } |
| |
| public int getGap() { |
| return gap; |
| } |
| |
| public int getLeadingGap() { |
| return leadingGap; |
| } |
| |
| public int getAfterCheckIconGap() { |
| return afterCheckIconGap; |
| } |
| |
| public int getMinTextOffset() { |
| return minTextOffset; |
| } |
| |
| public Rectangle getViewRect() { |
| return viewRect; |
| } |
| |
| public RectSize getIconSize() { |
| return iconSize; |
| } |
| |
| public RectSize getTextSize() { |
| return textSize; |
| } |
| |
| public RectSize getAccSize() { |
| return accSize; |
| } |
| |
| public RectSize getCheckSize() { |
| return checkSize; |
| } |
| |
| public RectSize getArrowSize() { |
| return arrowSize; |
| } |
| |
| public RectSize getLabelSize() { |
| return labelSize; |
| } |
| |
| protected void setMenuItem(JMenuItem mi) { |
| this.mi = mi; |
| } |
| |
| protected void setMenuItemParent(JComponent miParent) { |
| this.miParent = miParent; |
| } |
| |
| protected void setFont(Font font) { |
| this.font = font; |
| } |
| |
| protected void setAccFont(Font accFont) { |
| this.accFont = accFont; |
| } |
| |
| protected void setFontMetrics(FontMetrics fm) { |
| this.fm = fm; |
| } |
| |
| protected void setAccFontMetrics(FontMetrics accFm) { |
| this.accFm = accFm; |
| } |
| |
| protected void setIcon(Icon icon) { |
| this.icon = icon; |
| } |
| |
| protected void setCheckIcon(Icon checkIcon) { |
| this.checkIcon = checkIcon; |
| } |
| |
| protected void setArrowIcon(Icon arrowIcon) { |
| this.arrowIcon = arrowIcon; |
| } |
| |
| protected void setText(String text) { |
| this.text = text; |
| } |
| |
| protected void setAccText(String accText) { |
| this.accText = accText; |
| } |
| |
| protected void setColumnLayout(boolean columnLayout) { |
| isColumnLayout = columnLayout; |
| } |
| |
| protected void setUseCheckAndArrow(boolean useCheckAndArrow) { |
| this.useCheckAndArrow = useCheckAndArrow; |
| } |
| |
| protected void setLeftToRight(boolean leftToRight) { |
| isLeftToRight = leftToRight; |
| } |
| |
| protected void setTopLevelMenu(boolean topLevelMenu) { |
| isTopLevelMenu = topLevelMenu; |
| } |
| |
| protected void setHtmlView(View htmlView) { |
| this.htmlView = htmlView; |
| } |
| |
| protected void setVerticalAlignment(int verticalAlignment) { |
| this.verticalAlignment = verticalAlignment; |
| } |
| |
| protected void setHorizontalAlignment(int horizontalAlignment) { |
| this.horizontalAlignment = horizontalAlignment; |
| } |
| |
| protected void setVerticalTextPosition(int verticalTextPosition) { |
| this.verticalTextPosition = verticalTextPosition; |
| } |
| |
| protected void setHorizontalTextPosition(int horizontalTextPosition) { |
| this.horizontalTextPosition = horizontalTextPosition; |
| } |
| |
| protected void setGap(int gap) { |
| this.gap = gap; |
| } |
| |
| protected void setLeadingGap(int leadingGap) { |
| this.leadingGap = leadingGap; |
| } |
| |
| protected void setAfterCheckIconGap(int afterCheckIconGap) { |
| this.afterCheckIconGap = afterCheckIconGap; |
| } |
| |
| protected void setMinTextOffset(int minTextOffset) { |
| this.minTextOffset = minTextOffset; |
| } |
| |
| protected void setViewRect(Rectangle viewRect) { |
| this.viewRect = viewRect; |
| } |
| |
| protected void setIconSize(RectSize iconSize) { |
| this.iconSize = iconSize; |
| } |
| |
| protected void setTextSize(RectSize textSize) { |
| this.textSize = textSize; |
| } |
| |
| protected void setAccSize(RectSize accSize) { |
| this.accSize = accSize; |
| } |
| |
| protected void setCheckSize(RectSize checkSize) { |
| this.checkSize = checkSize; |
| } |
| |
| protected void setArrowSize(RectSize arrowSize) { |
| this.arrowSize = arrowSize; |
| } |
| |
| protected void setLabelSize(RectSize labelSize) { |
| this.labelSize = labelSize; |
| } |
| |
| public int getLeftTextExtraWidth() { |
| return leftTextExtraWidth; |
| } |
| |
| /** |
| * Returns false if the component is a JMenu and it is a top |
| * level menu (on the menubar). |
| */ |
| public static boolean useCheckAndArrow(JMenuItem menuItem) { |
| boolean b = true; |
| if ((menuItem instanceof JMenu) && |
| (((JMenu) menuItem).isTopLevelMenu())) { |
| b = false; |
| } |
| return b; |
| } |
| |
| public static class LayoutResult { |
| private Rectangle iconRect; |
| private Rectangle textRect; |
| private Rectangle accRect; |
| private Rectangle checkRect; |
| private Rectangle arrowRect; |
| private Rectangle labelRect; |
| |
| public LayoutResult() { |
| iconRect = new Rectangle(); |
| textRect = new Rectangle(); |
| accRect = new Rectangle(); |
| checkRect = new Rectangle(); |
| arrowRect = new Rectangle(); |
| labelRect = new Rectangle(); |
| } |
| |
| public LayoutResult(Rectangle iconRect, Rectangle textRect, |
| Rectangle accRect, Rectangle checkRect, |
| Rectangle arrowRect, Rectangle labelRect) { |
| this.iconRect = iconRect; |
| this.textRect = textRect; |
| this.accRect = accRect; |
| this.checkRect = checkRect; |
| this.arrowRect = arrowRect; |
| this.labelRect = labelRect; |
| } |
| |
| public Rectangle getIconRect() { |
| return iconRect; |
| } |
| |
| public void setIconRect(Rectangle iconRect) { |
| this.iconRect = iconRect; |
| } |
| |
| public Rectangle getTextRect() { |
| return textRect; |
| } |
| |
| public void setTextRect(Rectangle textRect) { |
| this.textRect = textRect; |
| } |
| |
| public Rectangle getAccRect() { |
| return accRect; |
| } |
| |
| public void setAccRect(Rectangle accRect) { |
| this.accRect = accRect; |
| } |
| |
| public Rectangle getCheckRect() { |
| return checkRect; |
| } |
| |
| public void setCheckRect(Rectangle checkRect) { |
| this.checkRect = checkRect; |
| } |
| |
| public Rectangle getArrowRect() { |
| return arrowRect; |
| } |
| |
| public void setArrowRect(Rectangle arrowRect) { |
| this.arrowRect = arrowRect; |
| } |
| |
| public Rectangle getLabelRect() { |
| return labelRect; |
| } |
| |
| public void setLabelRect(Rectangle labelRect) { |
| this.labelRect = labelRect; |
| } |
| |
| public Map<String, Rectangle> getAllRects() { |
| Map<String, Rectangle> result = new HashMap<String, Rectangle>(); |
| result.put("checkRect", checkRect); |
| result.put("iconRect", iconRect); |
| result.put("textRect", textRect); |
| result.put("accRect", accRect); |
| result.put("arrowRect", arrowRect); |
| result.put("labelRect", labelRect); |
| return result; |
| } |
| } |
| |
| public static class ColumnAlignment { |
| private int checkAlignment; |
| private int iconAlignment; |
| private int textAlignment; |
| private int accAlignment; |
| private int arrowAlignment; |
| |
| public static final ColumnAlignment LEFT_ALIGNMENT = |
| new ColumnAlignment( |
| SwingConstants.LEFT, |
| SwingConstants.LEFT, |
| SwingConstants.LEFT, |
| SwingConstants.LEFT, |
| SwingConstants.LEFT |
| ); |
| |
| public static final ColumnAlignment RIGHT_ALIGNMENT = |
| new ColumnAlignment( |
| SwingConstants.RIGHT, |
| SwingConstants.RIGHT, |
| SwingConstants.RIGHT, |
| SwingConstants.RIGHT, |
| SwingConstants.RIGHT |
| ); |
| |
| public ColumnAlignment(int checkAlignment, int iconAlignment, |
| int textAlignment, int accAlignment, |
| int arrowAlignment) { |
| this.checkAlignment = checkAlignment; |
| this.iconAlignment = iconAlignment; |
| this.textAlignment = textAlignment; |
| this.accAlignment = accAlignment; |
| this.arrowAlignment = arrowAlignment; |
| } |
| |
| public int getCheckAlignment() { |
| return checkAlignment; |
| } |
| |
| public int getIconAlignment() { |
| return iconAlignment; |
| } |
| |
| public int getTextAlignment() { |
| return textAlignment; |
| } |
| |
| public int getAccAlignment() { |
| return accAlignment; |
| } |
| |
| public int getArrowAlignment() { |
| return arrowAlignment; |
| } |
| } |
| |
| public static class RectSize { |
| private int width; |
| private int height; |
| private int origWidth; |
| private int maxWidth; |
| |
| public RectSize() { |
| } |
| |
| public RectSize(int width, int height, int origWidth, int maxWidth) { |
| this.width = width; |
| this.height = height; |
| this.origWidth = origWidth; |
| this.maxWidth = maxWidth; |
| } |
| |
| public int getWidth() { |
| return width; |
| } |
| |
| public int getHeight() { |
| return height; |
| } |
| |
| public int getOrigWidth() { |
| return origWidth; |
| } |
| |
| public int getMaxWidth() { |
| return maxWidth; |
| } |
| |
| public void setWidth(int width) { |
| this.width = width; |
| } |
| |
| public void setHeight(int height) { |
| this.height = height; |
| } |
| |
| public void setOrigWidth(int origWidth) { |
| this.origWidth = origWidth; |
| } |
| |
| public void setMaxWidth(int maxWidth) { |
| this.maxWidth = maxWidth; |
| } |
| |
| public String toString() { |
| return "[w=" + width + ",h=" + height + ",ow=" |
| + origWidth + ",mw=" + maxWidth + "]"; |
| } |
| } |
| } |
