X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=srcjar%2Fnet%2Fmiginfocom%2Flayout%2FPlatformDefaults.java;fp=srcjar%2Fnet%2Fmiginfocom%2Flayout%2FPlatformDefaults.java;h=0e422db8c1fc3aa5cd067f62832cea38274c32cf;hb=ec8f3cedf60fb1feed6d34de6b49f6bfa78b9dd8;hp=0000000000000000000000000000000000000000;hpb=056dad85a910551cc95e44d451a61f6b8c4dd35d;p=jalview.git diff --git a/srcjar/net/miginfocom/layout/PlatformDefaults.java b/srcjar/net/miginfocom/layout/PlatformDefaults.java new file mode 100644 index 0000000..0e422db --- /dev/null +++ b/srcjar/net/miginfocom/layout/PlatformDefaults.java @@ -0,0 +1,857 @@ +package net.miginfocom.layout; + +import java.util.HashMap; + +/* + * License (BSD): + * ============== + * + * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (miglayout (at) miginfocom (dot) com) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list + * of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + * list of conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * Neither the name of the MiG InfoCom AB nor the names of its contributors may be + * used to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * @version 1.0 + * @author Mikael Grev, MiG InfoCom AB + * Date: 2006-sep-08 + * @author Xxxx Xxxx, Xxxx - Gnome support + * Date: 2008-jan-16 + */ + +/** Currently handles Windows, Mac OS X, and GNOME spacing. + */ +public final class PlatformDefaults +{ + /** Property to use in LAF settings and as JComponent client property + * to specify the visual padding. + *

+ */ + public static String VISUAL_PADDING_PROPERTY = "visualPadding"; + + private static int DEF_H_UNIT = UnitValue.LPX; + private static int DEF_V_UNIT = UnitValue.LPY; + + private static InCellGapProvider GAP_PROVIDER = null; + + private static volatile int MOD_COUNT = 0; + +// private static final UnitValue LPX1 = new UnitValue(1, UnitValue.LPX, null); +// private static final UnitValue LPX4 = new UnitValue(4, UnitValue.LPX, null); + private static final UnitValue LPX6 = new UnitValue(6, UnitValue.LPX, null); + private static final UnitValue LPX7 = new UnitValue(7, UnitValue.LPX, null); +// private static final UnitValue LPX8 = new UnitValue(8, UnitValue.LPX, null); +// private static final UnitValue LPX9 = new UnitValue(9, UnitValue.LPX, null); +// private static final UnitValue LPX10 = new UnitValue(10, UnitValue.LPX, null); + private static final UnitValue LPX11 = new UnitValue(11, UnitValue.LPX, null); + private static final UnitValue LPX12 = new UnitValue(12, UnitValue.LPX, null); +// private static final UnitValue LPX14 = new UnitValue(14, UnitValue.LPX, null); + private static final UnitValue LPX16 = new UnitValue(16, UnitValue.LPX, null); + private static final UnitValue LPX18 = new UnitValue(18, UnitValue.LPX, null); + private static final UnitValue LPX20 = new UnitValue(20, UnitValue.LPX, null); + +// private static final UnitValue LPY1 = new UnitValue(1, UnitValue.LPY, null); +// private static final UnitValue LPY4 = new UnitValue(4, UnitValue.LPY, null); + private static final UnitValue LPY6 = new UnitValue(6, UnitValue.LPY, null); + private static final UnitValue LPY7 = new UnitValue(7, UnitValue.LPY, null); +// private static final UnitValue LPY8 = new UnitValue(8, UnitValue.LPY, null); +// private static final UnitValue LPY9 = new UnitValue(9, UnitValue.LPY, null); +// private static final UnitValue LPY10 = new UnitValue(10, UnitValue.LPY, null); + private static final UnitValue LPY11 = new UnitValue(11, UnitValue.LPY, null); + private static final UnitValue LPY12 = new UnitValue(12, UnitValue.LPY, null); +// private static final UnitValue LPY14 = new UnitValue(14, UnitValue.LPY, null); + private static final UnitValue LPY16 = new UnitValue(16, UnitValue.LPY, null); + private static final UnitValue LPY18 = new UnitValue(18, UnitValue.LPY, null); + private static final UnitValue LPY20 = new UnitValue(20, UnitValue.LPY, null); + + public static final int WINDOWS_XP = 0; + public static final int MAC_OSX = 1; + public static final int GNOME = 2; +// private static final int KDE = 3; + + private static int CUR_PLAF = WINDOWS_XP; + + // Used for holding values. + private final static UnitValue[] PANEL_INS = new UnitValue[4]; + private final static UnitValue[] DIALOG_INS = new UnitValue[4]; + + private static String BUTTON_FORMAT = null; + + private static final HashMap HOR_DEFS = new HashMap(32); + private static final HashMap VER_DEFS = new HashMap(32); + private static BoundSize DEF_VGAP = null, DEF_HGAP = null; + static BoundSize RELATED_X = null, RELATED_Y = null, UNRELATED_X = null, UNRELATED_Y = null; + private static UnitValue BUTT_WIDTH = null; + private static UnitValue BUTT_PADDING = null; + + private static Float horScale = null, verScale = null; + + /** I value indicating that the size of the font for the container of the component + * will be used as a base for calculating the logical pixel size. This is much as how + * Windows calculated DLU (dialog units). + * @see net.miginfocom.layout.UnitValue#LPX + * @see net.miginfocom.layout.UnitValue#LPY + * @see #setLogicalPixelBase(int) + */ + public static final int BASE_FONT_SIZE = 100; + + /** I value indicating that the screen DPI will be used as a base for calculating the + * logical pixel size. + *

+ * This is the default value. + * @see net.miginfocom.layout.UnitValue#LPX + * @see net.miginfocom.layout.UnitValue#LPY + * @see #setLogicalPixelBase(int) + * @see #setVerticalScaleFactor(Float) + * @see #setHorizontalScaleFactor(Float) + */ + public static final int BASE_SCALE_FACTOR = 101; + + /** I value indicating that the size of a logical pixel should always be a real pixel + * and thus no compensation will be made. + * @see net.miginfocom.layout.UnitValue#LPX + * @see net.miginfocom.layout.UnitValue#LPY + * @see #setLogicalPixelBase(int) + */ + public static final int BASE_REAL_PIXEL = 102; + + private static int LP_BASE = BASE_SCALE_FACTOR; + + private static Integer BASE_DPI_FORCED = null; + private static int BASE_DPI = 96; + + private static boolean dra = true; + + private static final HashMap VISUAL_BOUNDS = new HashMap(64); + + static { + setPlatform(getCurrentPlatform()); + MOD_COUNT = 0; + } + + /** Returns the platform that the JRE is running on currently. + * @return The platform that the JRE is running on currently. E.g. {@link #MAC_OSX}, {@link #WINDOWS_XP}, or {@link #GNOME}. + */ + public static int getCurrentPlatform() + { + if (/** @j2sNative true ||*/false) + return WINDOWS_XP; + final String os = System.getProperty("os.name"); + if (os.startsWith("Mac OS")) { + return MAC_OSX; + } else if (os.startsWith("Linux")) { + return GNOME; + } else { + return WINDOWS_XP; + } + } + + private PlatformDefaults() + { + } + + /** Set the defaults to the default for the platform + * @param plaf The platform. PlatformDefaults.WINDOWS_XP, + * PlatformDefaults.MAC_OSX, or + * PlatformDefaults.GNOME. + */ + public static void setPlatform(int plaf) + { + switch (plaf) { + case WINDOWS_XP: + setDefaultVisualPadding("TabbedPane." + VISUAL_PADDING_PROPERTY, new int[]{1, 0, 1, 2}); + setRelatedGap(LPX7, LPY7); + setUnrelatedGap(LPX11, LPY11); + setParagraphGap(LPX20, LPY20); + setIndentGap(LPX11, LPY11); + setGridCellGap(LPX7, LPY7); + + setMinimumButtonWidth(new UnitValue(75, UnitValue.LPX, null)); + setButtonOrder("L_E+U+YNBXOCAH_I_R"); + setDialogInsets(LPY11, LPX11, LPY11, LPX11); + setPanelInsets(LPY7, LPX7, LPY7, LPX7); + break; + + case MAC_OSX: + + setDefaultVisualPadding("Button." + VISUAL_PADDING_PROPERTY, new int[]{3, 6, 5, 6}); + setDefaultVisualPadding("Button.icon." + VISUAL_PADDING_PROPERTY, new int[]{3, 2, 3, 2}); + setDefaultVisualPadding("Button.square." + VISUAL_PADDING_PROPERTY, new int[]{4, 4, 4, 4}); + setDefaultVisualPadding("Button.square.icon." + VISUAL_PADDING_PROPERTY, new int[]{4, 4, 4, 4}); + setDefaultVisualPadding("Button.gradient." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.gradient.icon." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.bevel." + VISUAL_PADDING_PROPERTY, new int[]{2, 2, 3, 2}); + setDefaultVisualPadding("Button.bevel.icon." + VISUAL_PADDING_PROPERTY, new int[]{2, 2, 3, 2}); + setDefaultVisualPadding("Button.textured." + VISUAL_PADDING_PROPERTY, new int[]{3, 2, 3, 2}); + setDefaultVisualPadding("Button.textured.icon." + VISUAL_PADDING_PROPERTY, new int[]{3, 2, 3, 2}); + setDefaultVisualPadding("Button.roundRect." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.roundRect.icon." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.recessed." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.recessed.icon." + VISUAL_PADDING_PROPERTY, new int[]{5, 4, 5, 4}); + setDefaultVisualPadding("Button.help." + VISUAL_PADDING_PROPERTY, new int[]{4, 3, 3, 4}); + setDefaultVisualPadding("Button.help.icon." + VISUAL_PADDING_PROPERTY, new int[]{4, 3, 3, 4}); + + setDefaultVisualPadding("ComboBox." + VISUAL_PADDING_PROPERTY, new int[]{2, 4, 4, 5}); + setDefaultVisualPadding("ComboBox.isPopDown." + VISUAL_PADDING_PROPERTY, new int[]{2, 5, 4, 5}); + setDefaultVisualPadding("ComboBox.isSquare." + VISUAL_PADDING_PROPERTY, new int[]{1, 6, 5, 7}); + + setDefaultVisualPadding("ComboBox.editable." + VISUAL_PADDING_PROPERTY, new int[]{3, 3, 3, 2}); + setDefaultVisualPadding("ComboBox.editable.isSquare." + VISUAL_PADDING_PROPERTY, new int[]{3, 3, 3, 1}); + + setDefaultVisualPadding("TextField." + VISUAL_PADDING_PROPERTY, new int[]{3, 3, 3, 3}); + setDefaultVisualPadding("TabbedPane." + VISUAL_PADDING_PROPERTY, new int[]{4, 8, 11, 8}); + + setDefaultVisualPadding("Spinner." + VISUAL_PADDING_PROPERTY, new int[]{3, 3, 3, 1}); + + setDefaultVisualPadding("RadioButton." + VISUAL_PADDING_PROPERTY, new int[]{4, 6, 3, 5}); + setDefaultVisualPadding("RadioButton.small." + VISUAL_PADDING_PROPERTY, new int[]{4, 6, 3, 5}); + setDefaultVisualPadding("RadioButton.mini." + VISUAL_PADDING_PROPERTY, new int[]{5, 7, 4, 5}); + setDefaultVisualPadding("CheckBox." + VISUAL_PADDING_PROPERTY, new int[]{5, 7, 4, 5}); + setDefaultVisualPadding("CheckBox.small." + VISUAL_PADDING_PROPERTY, new int[]{5, 7, 4, 5}); + setDefaultVisualPadding("CheckBox.mini." + VISUAL_PADDING_PROPERTY, new int[]{6, 7, 3, 5}); + + setRelatedGap(LPX7, LPY7); + setUnrelatedGap(LPX11, LPY11); + setParagraphGap(LPX20, LPY20); + setIndentGap(LPX11, LPY11); + setGridCellGap(LPX7, LPY7); + + setMinimumButtonWidth(new UnitValue(70, UnitValue.LPX, null)); + setMinimumButtonPadding(new UnitValue(8, UnitValue.LPX, null)); + setButtonOrder("L_HE+U+NYBXCOA_I_R"); + setDialogInsets(LPY20, LPX20, LPY20, LPX20); + setPanelInsets(LPY16, LPX16, LPY16, LPX16); + break; + + case GNOME: + setRelatedGap(LPX6, LPY6); // GNOME HIG 8.2.3 + setUnrelatedGap(LPX12, LPY12); // GNOME HIG 8.2.3 + setParagraphGap(LPX18, LPY18); // GNOME HIG 8.2.3 + setIndentGap(LPX12, LPY12); // GNOME HIG 8.2.3 + setGridCellGap(LPX6, LPY6); // GNOME HIG 8.2.3 + + // GtkButtonBox, child-min-width property default value + setMinimumButtonWidth(new UnitValue(85, UnitValue.LPX, null)); + setButtonOrder("L_HE+UNYACBXO_I_R"); // GNOME HIG 3.4.2, 3.7.1 + setDialogInsets(LPY12, LPX12, LPY12, LPX12); // GNOME HIG 3.4.3 + setPanelInsets(LPY6, LPX6, LPY6, LPX6); // ??? + break; + default: + throw new IllegalArgumentException("Unknown platform: " + plaf); + } + CUR_PLAF = plaf; + BASE_DPI = BASE_DPI_FORCED != null ? BASE_DPI_FORCED : getPlatformDPI(plaf); + } + + /** Sets the visual bounds for a component type. + * @param key The component type. E.g. "TabbedPane.visualPadding" or "ComboBox.editable.isSquare.visualPadding". See source code for list. + * @param insets Top, left, bottom, right. Always length 4 or null. + * @see net.miginfocom.layout.ComponentWrapper#getVisualPadding() + */ + public static void setDefaultVisualPadding(String key, int[] insets) + { + VISUAL_BOUNDS.put(key, insets); + } + + /** Returns the visual bounds for a component type. + * @param key The component type. E.g. "TabbedPane.visualPadding" or "ComboBox.editable.isSquare.visualPadding". See source code for list. + * @return insets Top, left, bottom, right. Always length 4 or null. Live object, MUST NOT BE CHANGED!. + * @see net.miginfocom.layout.ComponentWrapper#getVisualPadding() + */ + public static int[] getDefaultVisualPadding(String key) + { + return VISUAL_BOUNDS.get(key); + } + + public static int getPlatformDPI(int plaf) + { + switch (plaf) { + case WINDOWS_XP: + case GNOME: + return 96; + case MAC_OSX: + try { + return java.awt.Toolkit.getDefaultToolkit().getScreenResolution(); + } catch (Throwable t) { + return 72; + } + default: + throw new IllegalArgumentException("Unknown platform: " + plaf); + } + } + + /** Returns the current platform + * @return PlatformDefaults.WINDOWS or PlatformDefaults.MAC_OSX + */ + public static int getPlatform() + { + return CUR_PLAF; + } + + public static int getDefaultDPI() + { + return BASE_DPI; + } + + /** Sets the default platform DPI. Normally this is set in the {@link #setPlatform(int)} for the different platforms + * but it can be tweaked here. For instance SWT on Mac does this. + *

+ * Note that this is not the actual current DPI, but the base DPI for the toolkit. + * @param dpi The base DPI. If null the default DPI is reset to the platform base DPI. + */ + public static void setDefaultDPI(Integer dpi) + { + BASE_DPI = dpi != null ? dpi : getPlatformDPI(CUR_PLAF); + BASE_DPI_FORCED = dpi; + } + + /** The forced scale factor that all screen relative units (e.g. millimeters, inches and logical pixels) will be multiplied + * with. If null this will default to a scale that will scale the current screen to the default screen resolution + * (72 DPI for Mac and 92 DPI for Windows). + * @return The forced scale or null for default scaling. + * @see #getHorizontalScaleFactor() + * @see ComponentWrapper#getHorizontalScreenDPI() + */ + public static Float getHorizontalScaleFactor() + { + return horScale; + } + + /** The forced scale factor that all screen relative units (e.g. millimeters, inches and logical pixels) will be multiplied + * with. If null this will default to a scale that will scale the current screen to the default screen resolution + * (72 DPI for Mac and 92 DPI for Windows). + * @param f The forced scale or null for default scaling. + * @see #getHorizontalScaleFactor() + * @see ComponentWrapper#getHorizontalScreenDPI() + */ + public static void setHorizontalScaleFactor(Float f) + { + if (!LayoutUtil.equals(horScale, f)) { + horScale = f; + MOD_COUNT++; + } + } + + /** The forced scale factor that all screen relative units (e.g. millimeters, inches and logical pixels) will be multiplied + * with. If null this will default to a scale that will scale the current screen to the default screen resolution + * (72 DPI for Mac and 92 DPI for Windows). + * @return The forced scale or null for default scaling. + * @see #getHorizontalScaleFactor() + * @see ComponentWrapper#getVerticalScreenDPI() + */ + public static Float getVerticalScaleFactor() + { + return verScale; + } + + /** The forced scale factor that all screen relative units (e.g. millimeters, inches and logical pixels) will be multiplied + * with. If null this will default to a scale that will scale the current screen to the default screen resolution + * (72 DPI for Mac and 92 DPI for Windows). + * @param f The forced scale or null for default scaling. + * @see #getHorizontalScaleFactor() + * @see ComponentWrapper#getVerticalScreenDPI() + */ + public static void setVerticalScaleFactor(Float f) + { + if (!LayoutUtil.equals(verScale, f)) { + verScale = f; + MOD_COUNT++; + } + } + + /** What base value should be used to calculate logical pixel sizes. + * @return The current base. Default is {@link #BASE_SCALE_FACTOR} + * @see #BASE_FONT_SIZE + * @see #BASE_SCALE_FACTOR + * @see #BASE_REAL_PIXEL +*/ + public static int getLogicalPixelBase() + { + return LP_BASE; + } + + /** What base value should be used to calculate logical pixel sizes. + * @param base The new base. Default is {@link #BASE_SCALE_FACTOR} + * @see #BASE_FONT_SIZE + * @see #BASE_SCALE_FACTOR + * @see #BASE_REAL_PIXEL + */ + public static void setLogicalPixelBase(int base) + { + if (LP_BASE != base) { + if (base < BASE_FONT_SIZE || base > BASE_REAL_PIXEL) + throw new IllegalArgumentException("Unrecognized base: " + base); + + LP_BASE = base; + MOD_COUNT++; + } + } + + /** Sets gap value for components that are "related". + * @param x The value that will be transformed to pixels. If null the current value will not change. + * @param y The value that will be transformed to pixels. If null the current value will not change. + */ + public static void setRelatedGap(UnitValue x, UnitValue y) + { + setUnitValue(new String[] {"r", "rel", "related"}, x, y); + + RELATED_X = new BoundSize(x, x, null, "rel:rel"); + RELATED_Y = new BoundSize(y, y, null, "rel:rel"); + } + + /** Sets gap value for components that are "unrelated". + * @param x The value that will be transformed to pixels. If null the current value will not change. + * @param y The value that will be transformed to pixels. If null the current value will not change. + */ + public static void setUnrelatedGap(UnitValue x, UnitValue y) + { + setUnitValue(new String[] {"u", "unrel", "unrelated"}, x, y); + + UNRELATED_X = new BoundSize(x, x, null, "unrel:unrel"); + UNRELATED_Y = new BoundSize(y, y, null, "unrel:unrel"); + } + + /** Sets paragraph gap value for components. + * @param x The value that will be transformed to pixels. If null the current value will not change. + * @param y The value that will be transformed to pixels. If null the current value will not change. + */ + public static void setParagraphGap(UnitValue x, UnitValue y) + { + setUnitValue(new String[] {"p", "para", "paragraph"}, x, y); + } + + /** Sets gap value for components that are "intended". + * @param x The value that will be transformed to pixels. If null the current value will not change. + * @param y The value that will be transformed to pixels. If null the current value will not change. + */ + public static void setIndentGap(UnitValue x, UnitValue y) + { + setUnitValue(new String[] {"i", "ind", "indent"}, x, y); + } + + /** Sets gap between two cells in the grid. Note that this is not a gap between component IN a cell, that has to be set + * on the component constraints. The value will be the min and preferred size of the gap. + * @param x The value that will be transformed to pixels. If null the current value will not change. + * @param y The value that will be transformed to pixels. If null the current value will not change. + */ + public static void setGridCellGap(UnitValue x, UnitValue y) + { + if (x != null) + DEF_HGAP = new BoundSize(x, x, null, null); + + if (y != null) + DEF_VGAP = new BoundSize(y, y, null, null); + + MOD_COUNT++; + } + + /** Sets the recommended minimum button width. + * @param width The recommended minimum button width. + */ + public static void setMinimumButtonWidth(UnitValue width) + { + BUTT_WIDTH = width; + MOD_COUNT++; + } + + /** Returns the recommended minimum button width depending on the current set platform. + * @return The recommended minimum button width depending on the current set platform. + */ + public static UnitValue getMinimumButtonWidth() + { + return BUTT_WIDTH; + } + + public static void setMinimumButtonPadding(UnitValue padding) + { + BUTT_PADDING = padding; + MOD_COUNT++; + } + + public static UnitValue getMinimumButtonPadding() + { + return BUTT_PADDING; + } + + public static float getMinimumButtonWidthIncludingPadding(float refValue, ContainerWrapper parent, ComponentWrapper comp) + { + final int buttonMinWidth = getMinimumButtonWidth().getPixels(refValue, parent, comp); + if (comp != null && getMinimumButtonPadding() != null) { + return Math.max(comp.getMinimumWidth(comp.getWidth()) + getMinimumButtonPadding().getPixels(refValue, parent, comp) * 2, buttonMinWidth); + } else { + return buttonMinWidth; + } + } + + /** Returns the unit value associated with the unit. (E.i. "related" or "indent"). Must be lower case. + * @param unit The unit string. + * @return The unit value associated with the unit. null for unrecognized units. + */ + public static UnitValue getUnitValueX(String unit) + { + return HOR_DEFS.get(unit); + } + + /** Returns the unit value associated with the unit. (E.i. "related" or "indent"). Must be lower case. + * @param unit The unit string. + * @return The unit value associated with the unit. null for unrecognized units. + */ + public static UnitValue getUnitValueY(String unit) + { + return VER_DEFS.get(unit); + } + + /** Sets the unit value associated with a unit string. This may be used to store values for new unit strings + * or modify old. Note that if a built in unit (such as "related") is modified all versions of it must be + * set (I.e. "r", "rel" and "related"). The build in values will be reset to the default ones if the platform + * is re-set. + * @param unitStrings The unit strings. E.g. "mu", "myunit". Will be converted to lower case and trimmed. Not null. + * @param x The value for the horizontal dimension. If null the value is not changed. + * @param y The value for the vertical dimension. Might be same object as for x. If null the value is not changed. + */ + public static void setUnitValue(String[] unitStrings, UnitValue x, UnitValue y) + { + for (String unitString : unitStrings) { + String s = unitString.toLowerCase().trim(); + if (x != null) + HOR_DEFS.put(s, x); + if (y != null) + VER_DEFS.put(s, y); + } + MOD_COUNT++; + } + + /** Understands ("r", "rel", "related") OR ("u", "unrel", "unrelated") OR ("i", "ind", "indent") OR ("p", "para", "paragraph"). + */ + static int convertToPixels(float value, String unit, boolean isHor, float ref, ContainerWrapper parent, ComponentWrapper comp) + { + UnitValue uv = (isHor ? HOR_DEFS : VER_DEFS).get(unit); + return uv != null ? Math.round(value * uv.getPixels(ref, parent, comp)) : UnitConverter.UNABLE; + } + + /** Returns the order for the typical buttons in a standard button bar. It is one letter per button type. + * @return The button order. + * @see #setButtonOrder(String) + */ + public static String getButtonOrder() + { + return BUTTON_FORMAT; + } + + /** Sets the order for the typical buttons in a standard button bar. It is one letter per button type. + *

+ * Letter in upper case will get the minimum button width that the {@link #getMinimumButtonWidth()} specifies + * and letters in lower case will get the width the current look&feel specifies. + *

+ * Gaps will never be added to before the first component or after the last component. However, '+' (push) will be + * applied before and after as well, but with a minimum size of 0 if first/last so there will not be a gap + * before or after. + *

+ * If gaps are explicitly set on buttons they will never be reduced, but they may be increased. + *

+ * These are the characters that can be used: + *

+ *

+ * Even though the style tags are normally applied to buttons this works with all components. + *

+ * The normal style for MAC OS X is "L_HE+U+NYBXCOA_I_R", + * for Windows is "L_E+U+YNBXOCAH_I_R", and for GNOME is + * "L_HE+UNYACBXO_I_R". + * + * @param order The new button order for the current platform. + */ + public static void setButtonOrder(String order) + { + BUTTON_FORMAT = order; + MOD_COUNT++; + } + + /** Returns the tag (used in the {@link CC}) for a char. The char is same as used in {@link #getButtonOrder()}. + * @param c The char. Must be lower case! + * @return The tag that corresponds to the char or null if the char is unrecognized. + */ + static String getTagForChar(char c) + { + switch (c) { + case 'o': + return "ok"; + case 'c': + return "cancel"; + case 'h': + return "help"; + case 'e': + return "help2"; + case 'y': + return "yes"; + case 'n': + return "no"; + case 'a': + return "apply"; + case 'x': + return "next"; // a.k.a forward + case 'b': + return "back"; // a.k.a. previous + case 'i': + return "finish"; + case 'l': + return "left"; + case 'r': + return "right"; + case 'u': + return "other"; + default: + return null; + } + } + + /** Returns the platform recommended inter-cell gap in the horizontal (x) dimension.. + * @return The platform recommended inter-cell gap in the horizontal (x) dimension.. + */ + public static BoundSize getGridGapX() + { + return DEF_HGAP; + } + + /** Returns the platform recommended inter-cell gap in the vertical (x) dimension.. + * @return The platform recommended inter-cell gap in the vertical (x) dimension.. + */ + public static BoundSize getGridGapY() + { + return DEF_VGAP; + } + + /** Returns the default dialog insets depending of the current platform. + * @param side top == 0, left == 1, bottom = 2, right = 3. + * @return The insets. Never null. + */ + public static UnitValue getDialogInsets(int side) + { + return DIALOG_INS[side]; + } + + /** Sets the default insets for a dialog. Values that are null will not be changed. + * @param top The top inset. May be null. + * @param left The left inset. May be null. + * @param bottom The bottom inset. May be null. + * @param right The right inset. May be null. + */ + public static void setDialogInsets(UnitValue top, UnitValue left, UnitValue bottom, UnitValue right) + { + if (top != null) + DIALOG_INS[0] = top; + + if (left != null) + DIALOG_INS[1] = left; + + if (bottom != null) + DIALOG_INS[2] = bottom; + + if (right != null) + DIALOG_INS[3] = right; + + MOD_COUNT++; + } + + /** Returns the default panel insets depending of the current platform. + * @param side top == 0, left == 1, bottom = 2, right = 3. + * @return The insets. Never null. + */ + public static UnitValue getPanelInsets(int side) + { + return PANEL_INS[side]; + } + + /** Sets the default insets for a dialog. Values that are null will not be changed. + * @param top The top inset. May be null. + * @param left The left inset. May be null. + * @param bottom The bottom inset. May be null. + * @param right The right inset. May be null. + */ + public static void setPanelInsets(UnitValue top, UnitValue left, UnitValue bottom, UnitValue right) + { + if (top != null) + PANEL_INS[0] = top; + + if (left != null) + PANEL_INS[1] = left; + + if (bottom != null) + PANEL_INS[2] = bottom; + + if (right != null) + PANEL_INS[3] = right; + + MOD_COUNT++; + } + + /** Returns the percentage used for alignment for labels (0 is left, 50 is center and 100 is right). + * @return The percentage used for alignment for labels + */ + public static float getLabelAlignPercentage() + { + return CUR_PLAF == MAC_OSX ? 1f : 0f; + } + + /** Returns the default gap between two components that are in the same cell. + * @param comp The component that the gap is for. Never null. + * @param adjacentComp The adjacent component if any. May be null. + * @param adjacentSide What side the adjacentComp is on. {@link javax.swing.SwingUtilities#TOP} (1) or + * {@link javax.swing.SwingUtilities#LEFT} (2) or {@link javax.swing.SwingUtilities#BOTTOM} (3) or {@link javax.swing.SwingUtilities#RIGHT} (4). + * @param tag The tag string that the component might be tagged with in the component constraints. May be null. + * @param isLTR If it is left-to-right. + * @return The default gap between two components or null if there should be no gap. + */ + static BoundSize getDefaultComponentGap(ComponentWrapper comp, ComponentWrapper adjacentComp, int adjacentSide, String tag, boolean isLTR) + { + if (GAP_PROVIDER != null) + return GAP_PROVIDER.getDefaultGap(comp, adjacentComp, adjacentSide, tag, isLTR); + + if (adjacentComp == null) + return null; + +// if (adjacentComp == null || adjacentSide == SwingConstants.LEFT || adjacentSide == SwingConstants.TOP) +// return null; + +// SwingConstants.RIGHT == 4, SwingConstants.LEFT == 2 + return (adjacentSide == 2 || adjacentSide == 4) ? RELATED_X : RELATED_Y; + } + + /** Returns the current gap provider or null if none is set and "related" should always be used. + * @return The current gap provider or null if none is set and "related" should always be used. + */ + public static InCellGapProvider getGapProvider() + { + return GAP_PROVIDER; + } + + /** Sets the current gap provider or null if none is set and "related" should always be used. + * @param provider The current gap provider or null if none is set and "related" should always be used. + */ + public static void setGapProvider(InCellGapProvider provider) + { + GAP_PROVIDER = provider; + } + + /** Returns how many times the defaults has been changed. This can be used as a light weight check to + * see if layout caches needs to be refreshed. + * @return How many times the defaults has been changed. + */ + public static int getModCount() + { + return MOD_COUNT; + } + + /** Tells all layout manager instances to revalidate and recalculated everything. + */ + public void invalidate() + { + MOD_COUNT++; + } + + /** Returns the current default unit. The default unit is the unit used if no unit is set. E.g. "width 10". + * @return The current default unit. + * @see UnitValue#PIXEL + * @see UnitValue#LPX + */ + public static int getDefaultHorizontalUnit() + { + return DEF_H_UNIT; + } + + /** Sets the default unit. The default unit is the unit used if no unit is set. E.g. "width 10". + * @param unit The new default unit. + * @see UnitValue#PIXEL + * @see UnitValue#LPX + */ + public static void setDefaultHorizontalUnit(int unit) + { + if (unit < UnitValue.PIXEL || unit > UnitValue.LABEL_ALIGN) + throw new IllegalArgumentException("Illegal Unit: " + unit); + + if (DEF_H_UNIT != unit) { + DEF_H_UNIT = unit; + MOD_COUNT++; + } + } + + /** Returns the current default unit. The default unit is the unit used if no unit is set. E.g. "width 10". + * @return The current default unit. + * @see UnitValue#PIXEL + * @see UnitValue#LPY + */ + public static int getDefaultVerticalUnit() + { + return DEF_V_UNIT; + } + + /** Sets the default unit. The default unit is the unit used if no unit is set. E.g. "width 10". + * @param unit The new default unit. + * @see UnitValue#PIXEL + * @see UnitValue#LPY + */ + public static void setDefaultVerticalUnit(int unit) + { + if (unit < UnitValue.PIXEL || unit > UnitValue.LABEL_ALIGN) + throw new IllegalArgumentException("Illegal Unit: " + unit); + + if (DEF_V_UNIT != unit) { + DEF_V_UNIT = unit; + MOD_COUNT++; + } + } + + /** The default alignment for rows. Pre v3.5 this was false but now it is + * true. + * @return The current value. Default is true. + * @since 3.5 + */ + public static boolean getDefaultRowAlignmentBaseline() + { + return dra; + } + + /** The default alignment for rows. Pre v3.5 this was false but now it is + * true. + * @param b The new value. Default is true from v3.5. + * @since 3.5 + */ + public static void setDefaultRowAlignmentBaseline(boolean b) + { + dra = b; + } +}