/*
 * 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;
 }

 @SuppressWarnings("deprecation")
 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 + "]";
 }
 }
}