Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package net.miginfocom.layout;
  /*
   * 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
  */
 
 import java.io.*;
 
 public final class UnitValue implements Serializable
 {
 	private static final HashMap<StringIntegerUNIT_MAP = new HashMap<StringInteger>(32);
 
 	private static final ArrayList<UnitConverterCONVERTERS = new ArrayList<UnitConverter>();

An operation indicating a static value.
 
 	public static final int STATIC = 100;

An operation indicating a addition of two sub units.
 
 	public static final int ADD = 101; // Must have "sub-unit values"
 
An operation indicating a subtraction of two sub units
 
 	public static final int SUB = 102; // Must have "sub-unit values"
 
An operation indicating a multiplication of two sub units.
 
 	public static final int MUL = 103; // Must have "sub-unit values"
 
An operation indicating a division of two sub units.
 
 	public static final int DIV = 104; // Must have "sub-unit values"
 
An operation indicating the minimum of two sub units
 
 	public static final int MIN = 105; // Must have "sub-unit values"
 
An operation indicating the maximum of two sub units
 
 	public static final int MAX = 106; // Must have "sub-unit values"
 
An operation indicating the middle value of two sub units
 
 	public static final int MID = 107; // Must have "sub-unit values"
 



A unit indicating pixels.
 
 	public static final int PIXEL = 0;

A unit indicating logical horizontal pixels.
 
 	public static final int LPX = 1;

A unit indicating logical vertical pixels.
 
 	public static final int LPY = 2;

A unit indicating millimeters.
 
 	public static final int MM = 3;

A unit indicating centimeters.
	public static final int CM = 4;

A unit indicating inches.
	public static final int INCH = 5;

A unit indicating percent.
	public static final int PERCENT = 6;

A unit indicating points.
	public static final int PT = 7;

A unit indicating screen percentage width.
	public static final int SPX = 8;

A unit indicating screen percentage height.
	public static final int SPY = 9;

A unit indicating alignment.
	public static final int ALIGN = 12;

A unit indicating minimum size.
	public static final int MIN_SIZE = 13;

A unit indicating preferred size.
	public static final int PREF_SIZE = 14;

A unit indicating maximum size.
	public static final int MAX_SIZE = 15;

A unit indicating botton size.
	public static final int BUTTON = 16;

A unit indicating linking to x.
	public static final int LINK_X = 18;   // First link
A unit indicating linking to y.
	public static final int LINK_Y = 19;

A unit indicating linking to width.
	public static final int LINK_W = 20;

A unit indicating linking to height.
	public static final int LINK_H = 21;

A unit indicating linking to x2.
	public static final int LINK_X2 = 22;

A unit indicating linking to y2.
	public static final int LINK_Y2 = 23;

A unit indicating linking to x position on screen.
	public static final int LINK_XPOS = 24;

A unit indicating linking to y position on screen.
	public static final int LINK_YPOS = 25;    // Last link
A unit indicating a lookup.
	public static final int LOOKUP = 26;

A unit indicating label alignment.
	public static final int LABEL_ALIGN = 27;
	private static final int IDENTITY = -1;
	static {
		.put("lpx");
		.put("lpy");
		.put("cm");
		.put("in");
		.put("spx");
		.put("spy");
		.put("mm");
		.put("pt");
		.put("minimum");
		.put("maximum");
		.put("button");
	}
	static final UnitValue ZERO = new UnitValue(0, nulltruenullnull"0px");
	static final UnitValue TOP = new UnitValue(0, nullfalsenullnull"top");
	static final UnitValue LEADING = new UnitValue(0, nulltruenullnull"leading");
	static final UnitValue LEFT = new UnitValue(0, nulltruenullnull"left");
	static final UnitValue CENTER = new UnitValue(50, nulltruenullnull"center");
	static final UnitValue TRAILING = new UnitValue(100, nulltruenullnull"trailing");
	static final UnitValue RIGHT = new UnitValue(100, nulltruenullnull"right");
	static final UnitValue BOTTOM = new UnitValue(100, nullfalsenullnull"bottom");
	static final UnitValue LABEL = new UnitValue(0, nullfalsenullnull"label");
	static final UnitValue INF = new UnitValue(.nulltruenullnull"inf");
	static final UnitValue BASELINE_IDENTITY = new UnitValue(0, nullfalsenullnull"baseline");
	private final transient float value;
	private final transient int unit;
	private final transient int oper;
	private final transient String unitStr;
	private transient String linkId = null// Should be final, but initializes in a sub method.
	private final transient boolean isHor;
	private final transient UnitValue[] subUnits;
	// Pixel
	public UnitValue(float value)  // If hor/ver does not matter.
	{
		this(valuenulltruenullnullvalue + "px");
	}
	public UnitValue(float valueint unitString createString)  // If hor/ver does not matter.
	{
		this(valuenullunittruenullnullcreateString);
	}
	UnitValue(float valueString unitStrboolean isHorint operString createString)
	{
		this(valueunitStr, -1, isHoropernullnullcreateString);
	}
	UnitValue(boolean isHorint operUnitValue sub1UnitValue sub2String createString)
	{
		this(0, "", -1, isHoropersub1sub2createString);
		if (sub1 == null || sub2 == null)
			throw new IllegalArgumentException("Sub units is null!");
	}
	private UnitValue(float valueString unitStrint unitboolean isHorint operUnitValue sub1UnitValue sub2String createString)
	{
		if (oper <  || oper > )
			throw new IllegalArgumentException("Unknown Operation: " + oper);
		if (oper >=  && oper <=  && (sub1 == null || sub2 == null))
			throw new IllegalArgumentException(oper + " Operation may not have null sub-UnitValues.");
		this. = value;
		this. = oper;
		this. = isHor;
		this. = unitStr;
		this. = unitStr != null ? parseUnitString() : unit;
		this. = sub1 != null && sub2 != null ? new UnitValue[] {sub1sub2} : null;
		LayoutUtil.putCCString(thiscreateString);    // "this" escapes!! Safe though.
	}

Returns the size in pixels rounded.

Parameters:
refValue The reference value. Normally the size of the parent. For unit ALIGN the current size of the component should be sent in.
parent The parent. May be null for testing the validity of the value, but should normally not and are not required to return any usable value if null.
comp The component, if any, that the value is for. Might be null if the value is not connected to any component.
Returns:
The size in pixels.
	public final int getPixels(float refValueContainerWrapper parentComponentWrapper comp)
	{
		return Math.round(getPixelsExact(refValueparentcomp));
	}
	private static final float[] SCALE = new float[] {25.4f, 2.54f, 1f, 0f, 72f};
Returns the size in pixels.

Parameters:
refValue The reference value. Normally the size of the parent. For unit ALIGN the current size of the component should be sent in.
parent The parent. May be null for testing the validity of the value, but should normally not and are not required to return any usable value if null.
comp The component, if any, that the value is for. Might be null if the value is not connected to any component.
Returns:
The size in pixels.
	public final float getPixelsExact(float refValueContainerWrapper parentComponentWrapper comp)
	{
		if (parent == null)
			return 1;
		if ( == ) {
			switch () {
				case :
					return ;
				case :
				case :
					return parent.getPixelUnitFactor( == ) * ;
				case :
				case :
				case :
				case :
					float f = [ - ];
					Float s =  ? PlatformDefaults.getHorizontalScaleFactor() : PlatformDefaults.getVerticalScaleFactor();
					if (s != null)
						f *= s;
					return ( ? parent.getHorizontalScreenDPI() : parent.getVerticalScreenDPI()) *  / f;
				case :
					return  * refValue * 0.01f;
				case :
				case :
					return ( ==  ? parent.getScreenWidth() : parent.getScreenHeight()) *  * 0.01f;
				case :
					Integer st = LinkHandler.getValue(parent.getLayout(), "visual" ? . : .);
					Integer sz = LinkHandler.getValue(parent.getLayout(), "visual" ? . : .);
					if (st == null || sz == null)
						return 0;
					return  * (Math.max(0, sz.intValue()) - refValue) + st;
				case :
					if (comp == null)
						return 0;
					return  ? comp.getMinimumWidth(comp.getHeight()) : comp.getMinimumHeight(comp.getWidth());
				case :
					if (comp == null)
						return 0;
					return  ? comp.getPreferredWidth(comp.getHeight()) : comp.getPreferredHeight(comp.getWidth());
				case :
					if (comp == null)
						return 0;
					return  ? comp.getMaximumWidth(comp.getHeight()) : comp.getMaximumHeight(comp.getWidth());
				case :
					return PlatformDefaults.getMinimumButtonWidth().getPixels(refValueparentcomp);
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
					Integer v = LinkHandler.getValue(parent.getLayout(), getLinkTargetId(),  - ( >=  ?  : ));
					if (v == null)
						return 0;
					if ( == )
						return parent.getScreenLocationX() + v;
					if ( == )
						return parent.getScreenLocationY() + v;
					return v;
				case :
					float res = lookup(refValueparentcomp);
					if (res != .)
						return res;
					return PlatformDefaults.getLabelAlignPercentage() * refValue;
				case :
			}
			throw new IllegalArgumentException("Unknown/illegal unit: " +  + ", unitStr: " + );
		}
		if ( != null && . == 2) {
			float r1 = [0].getPixelsExact(refValueparentcomp);
			float r2 = [1].getPixelsExact(refValueparentcomp);
			switch () {
				case :
					return r1 + r2;
				case :
					return r1 - r2;
				case :
					return r1 * r2;
				case :
					return r1 / r2;
				case :
					return r1 < r2 ? r1 : r2;
				case :
					return r1 > r2 ? r1 : r2;
				case :
					return (r1 + r2) * 0.5f;
			}
		}
		throw new IllegalArgumentException("Internal: Unknown Oper: " + );
	}
	private float lookup(float refValueContainerWrapper parentComponentWrapper comp)
	{
		float res = .;
		for (int i = .size() - 1; i >= 0; i--) {
			res = .get(i).convertToPixels(refValueparentcomp);
			if (res != .)
				return res;
		}
		return PlatformDefaults.convertToPixels(refValueparentcomp);
	}
	private int parseUnitString()
	{
		int len = .length();
		if (len == 0)
			return  ? PlatformDefaults.getDefaultHorizontalUnit() : PlatformDefaults.getDefaultVerticalUnit();
		if (u != null)
			return u;
		if (.equals("lp"))
			return  ?  : ;
		if (.equals("sp"))
			return  ?  : ;
		if (lookup(0, nullnull) != .)    // To test so we can fail fast
			return ;
		// Only link left. E.g. "otherID.width"
		int pIx = .indexOf('.');
		if (pIx != -1) {
			 = .substring(0, pIx);
			String e = .substring(pIx + 1);
			if (e.equals("x"))
				return ;
			if (e.equals("y"))
				return ;
			if (e.equals("w") || e.equals("width"))
				return ;
			if (e.equals("h") || e.equals("height"))
				return ;
			if (e.equals("x2"))
				return ;
			if (e.equals("y2"))
				return ;
			if (e.equals("xpos"))
				return ;
			if (e.equals("ypos"))
				return ;
		}
		throw new IllegalArgumentException("Unknown keyword: " + );
	}
	final boolean isLinked()
	{
		return  != null;
	}
	final boolean isLinkedDeep()
	{
		if ( == null)
			return  != null;
		for (UnitValue subUnit : ) {
			if (subUnit.isLinkedDeep())
				return true;
		}
		return false;
	}
	{
		return ;
	}
	final UnitValue getSubUnitValue(int i)
	{
		return [i];
	}
	final int getSubUnitCount()
	{
		return  != null ? . : 0;
	}
	public final UnitValue[] getSubUnits()
	{
		return  != null ? .clone() : null;
	}
	public final int getUnit()
	{
		return ;
	}
	public final String getUnitString()
	{
		return ;
	}
	public final int getOperation()
	{
		return ;
	}
	public final float getValue()
	{
		return ;
	}
	public final boolean isHorizontal()
	{
		return ;
	}
	final public String toString()
	{
		return getClass().getName() + ". Value=" +  + ", unit=" +  + ", unitString: " +  + ", oper=" +  + ", isHor: " + ;
	}

Returns the creation string for this object. Note that LayoutUtil.setDesignTime(net.miginfocom.layout.ContainerWrapper,boolean) must be set to true for the creation strings to be stored.

Returns:
The constraint string or null if none is registered.
	public final String getConstraintString()
	{
		return LayoutUtil.getCCString(this);
	}
	public final int hashCode()
	{
		return (int) ( * 12345) + ( >>> 5) +  >>> 17;
	}

Adds a global unit converter that can convert from some unit to pixels.

This converter will be asked before the platform converter so the values for it (e.g. "related" and "unrelated") can be overridden. It is however not possible to override the built in ones (e.g. "mm", "pixel" or "lp").

Parameters:
conv The converter. Not null.
	public synchronized static void addGlobalUnitConverter(UnitConverter conv)
	{
		if (conv == null)
			throw new NullPointerException();
	}

Removed the converter.

Parameters:
unit The converter.
Returns:
If there was a converter found and thus removed.
	public synchronized static boolean removeGlobalUnitConverter(UnitConverter unit)
	{
		return .remove(unit);
	}

Returns the global converters currently registered. The platform converter will not be in this list.

Returns:
The converters. Never null.
	public synchronized static UnitConverter[] getGlobalUnitConverters()
	{
	}

Returns the current default unit. The default unit is the unit used if no unit is set. E.g. "width 10".

Deprecated:
Use PlatformDefaults.getDefaultHorizontalUnit() and PlatformDefaults.getDefaultVerticalUnit() instead.
Returns:
The current default unit.
See also:
PIXEL
LPX
	public static int getDefaultUnit()
	{
		return PlatformDefaults.getDefaultHorizontalUnit();
	}

Sets the default unit. The default unit is the unit used if no unit is set. E.g. "width 10".

Deprecated:
Use PlatformDefaults.setDefaultHorizontalUnit(int) and PlatformDefaults.setDefaultVerticalUnit(int) instead.
Parameters:
unit The new default unit.
See also:
PIXEL
LPX
	public static void setDefaultUnit(int unit)
	{
		PlatformDefaults.setDefaultHorizontalUnit(unit);
		PlatformDefaults.setDefaultVerticalUnit(unit);
	}
	static {
        if(.){
            LayoutUtil.setDelegate(UnitValue.classnew PersistenceDelegate() {
                protected Expression instantiate(Object oldInstanceEncoder out)
                {
                    UnitValue uv = (UnitValueoldInstance;
                    String cs = uv.getConstraintString();
                    if (cs == null)
                        throw new IllegalStateException("Design time must be on to use XML persistence. See LayoutUtil.");
                    return new Expression(oldInstanceConstraintParser.class"parseUnitValueOrAlign"new Object[] {
                            uv.getConstraintString(), (uv.isHorizontal() ? . : .), null
                    });
                }
            });
        }
	}
	// ************************************************
	// Persistence Delegate and Serializable combined.
	// ************************************************
	private static final long serialVersionUID = 1L;
	{
		return LayoutUtil.getSerializedObject(this);
	}
	private void writeObject(ObjectOutputStream outthrows IOException
	{
		if (getClass() == UnitValue.class)
			LayoutUtil.writeAsXML(outthis);
	}
	{
		LayoutUtil.setSerializedObject(this, LayoutUtil.readAsXML(in));
	}
New to GrepCode? Check out our FAQ X