Attachment #189674 for bug #324436

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2007, 2011 Innoopract Informationssysteme GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *     Innoopract Informationssysteme GmbH - initial API and implementation
 *     EclipseSource - ongoing development
 ******************************************************************************/

package org.eclipse.rwt.internal.theme;


  private static final Map NAMED_COLORS = new HashMap();

  public static final QxColor BLACK = new QxColor( 0, 0, 0, 1f );

  public static final QxColor WHITE = new QxColor( 255, 255, 255, 1f );

  public static final QxColor TRANSPARENT = new QxColor();


  public final int green;

  public final int blue;
  
  public final float alpha;

  static {
    // register 16 standard HTML colors

    this.red = 0;
    this.green = 0;
    this.blue = 0;
    this.alpha = 0f;
  }

  private QxColor( final int red,
                   final int green,
                   final int blue,
                   final float alpha )
  {
    this.red = red;
    this.green = green;
    this.blue = blue;
    this.alpha = alpha;
  }

  public static QxColor create( final int red, final int green, final int blue )

    } else if( red == 255 && green == 255 && blue == 255 ) {
      result = WHITE;
    } else {
      result = new QxColor( red, green, blue, 1f );
    }
    return result;
  }
  
  public static QxColor create( final int red,
                                final int green,
                                final int blue,
                                final float alpha )
  {
    checkAlpha( alpha );
    QxColor result;
    if( alpha == 1f ) {
      result = create( red, green, blue );
    } else {
      result = new QxColor( red, green, blue, alpha );
    }
    return result;
  }

  private static void checkAlpha( final float alpha ) {
    if( alpha < 0 || alpha > 1 ) {
      String msg = "Alpha out of range [ 0, 1 ]: " + alpha;
      throw new IllegalArgumentException( msg );
    }
  }

  public static QxColor valueOf( final String input ) {
    QxColor result;

      result = TRANSPARENT;
    } else {
      int red, green, blue;
      float alpha = 1f;
      String lowerCaseInput = input.toLowerCase( Locale.ENGLISH );
      if( input.startsWith( "#" ) ) {
        try {

        blue = values[ 2 ];
      } else {
        String[] parts = input.split( "\\s*,\\s*" );
        if( parts.length >= 3 && parts.length <= 4 ) {
          try {
            red = Integer.parseInt( parts[ 0 ] );
            green = Integer.parseInt( parts[ 1 ] );
            blue = Integer.parseInt( parts[ 2 ] );
            if( parts.length == 4 ) {
              alpha = Float.parseFloat( parts[ 3 ] );
            }
          } catch( final NumberFormatException e ) {
            String pattern = "Illegal number format in color definition ''{0}''";
            Object[] arguments = new Object[] { input };

          throw new IllegalArgumentException( message );
        }
      }
      result = create( red, green, blue, alpha );
    }
    return result;
  }

  public boolean isTransparent() {
    return alpha == 0f;
  }

  public String toDefaultString() {
    String result;
    if( isTransparent() ) {
      result = TRANSPARENT_STR;
    } else if( alpha == 1f ) {
      result = toHtmlString( red, green, blue );
    } else {
      result = toRgbaString( red, green, blue, alpha );
    }
    return result;
  }

  public boolean equals( final Object obj ) {

      QxColor other = ( QxColor )obj;
      result =  other.red == red
             && other.green == green
             && other.blue == blue
             && other.alpha == alpha;
    }
    return result;
  }

  public int hashCode() {
    int result = -1;
    if( !isTransparent() ) {
      result = 41;
      result += 19 * result + red;
      result += 19 * result + green;
      result += 19 * result + blue;
      result += 19 * result + Float.floatToIntBits( alpha );
    }
    return result;
  }

  public String toString() {
    String colors = red + ", " + green + ", " + blue + ", " + alpha;
    return "QxColor{ " + ( isTransparent() ? TRANSPARENT_STR : colors ) + " }";
  }

  public static String toHtmlString( final int red,


  public static Color createColor( final QxColor color ) {
    Color result = null;
    if( color.alpha == 1f ) {
      result = Graphics.getColor( color.red, color.green, color.blue );
    }
    return result;

    String hex = Integer.toHexString( value );
    return hex.length() == 1 ? "0" + hex : hex;
  }

  private static String toRgbaString( final int red,
                                      final int green,
                                      final int blue,
                                      final float alpha )
  {
    StringBuffer sb = new StringBuffer();
    sb.append( "rgba(" );
    sb.append( red );
    sb.append( "," );
    sb.append( green );
    sb.append( "," );
    sb.append( blue );
    sb.append( "," );
    sb.append( alpha );
    sb.append( ")" );
    return sb.toString();
  }
}




/*******************************************************************************
 * Copyright (c) 2011 EclipseSource and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution, 
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   EclipseSource - initial API and implementation
 ******************************************************************************/
package org.eclipse.rwt.internal.theme;


public class QxShadow implements QxType {
  
  public static final QxShadow NONE
    = new QxShadow( false, 0 , 0, 0, 0, null, 0 );
  
  public final boolean inset;
  public final int offsetX;
  public final int offsetY;
  public final int blur;
  public final int spread;
  public final String color;
  public final float opacity;
  
  private QxShadow( final boolean inset,
                    final int offsetX,
                    final int offsetY,
                    final int blur,
                    final int spread,
                    final String color,
                    final float opacity )
  {
    this.inset = inset;
    this.offsetX = offsetX;
    this.offsetY = offsetY;
    this.blur = blur;
    this.spread = spread;
    this.color = color;
    this.opacity = opacity;
  }
  
  public static QxShadow create( final boolean inset,
                                 final int offsetX,
                                 final int offsetY,
                                 final int blur,
                                 final int spread,
                                 final QxColor color )
  {
    String msg;
    if( inset ) {
      msg = "Shadow \"inset\" keyword is not supported";
      throw new IllegalArgumentException( msg );
    }
    if( blur < 0 ) {
      msg = "Shadow blur distance can't be negative";
      throw new IllegalArgumentException( msg );
    }
    if( spread != 0 ) {
      msg = "Shadow spread distance is not supported";
      throw new IllegalArgumentException( msg );
    }
    if( color == null ) {
      throw new NullPointerException( "null argument" );
    }
    String htmlColor = QxColor.toHtmlString( color.red,
                                             color.green,
                                             color.blue );
    return new QxShadow( inset,
                         offsetX,
                         offsetY,
                         blur,
                         spread,
                         htmlColor,
                         color.alpha );
  }

  public boolean equals( final Object obj ) {
    boolean result = false;
    if( obj == this ) {
      result = true;
    } else if( obj instanceof QxShadow ) {
      QxShadow other = ( QxShadow )obj;
      result =  other.inset == inset
             && other.offsetX == offsetX
             && other.offsetY == offsetY
             && other.blur == blur
             && other.spread == spread
             && ( color == null
                  ? other.color == null
                  : color.equals( other.color ) )
             && other.opacity == opacity;
    }
    return result;
  }
  
  public int hashCode() {
    int result = 17;
    result += 11 * result + offsetX;
    result += 11 * result + offsetY;
    result += 11 * result + blur;
    result += 11 * result + spread;
    if( color != null ) {
      result += 11 * result + color.hashCode();
    }
    result += 11 * result + Float.floatToIntBits( opacity );
    result += inset ? 0 : 11 * result + 13;
    return result;
  }

  public String toDefaultString() {
    StringBuffer buffer = new StringBuffer();
    if( color == null ) {
      buffer.append( "none" );
    } else {
      if( inset ) {
        buffer.append( "inset " );
      }
      buffer.append( offsetX );
      buffer.append( "px " );
      buffer.append( offsetY );
      buffer.append( "px " );
      buffer.append( blur );
      buffer.append( "px " );
      buffer.append( spread );
      buffer.append( "px " );
      buffer.append( "rgba( " );
      QxColor qxColor = QxColor.valueOf( color );
      buffer.append( qxColor.red );
      buffer.append( ", " );
      buffer.append( qxColor.green );
      buffer.append( ", " );
      buffer.append( qxColor.blue );
      buffer.append( ", " );
      buffer.append( opacity );
      buffer.append( " )" );
    }
    return buffer.toString();
  }
  
  public String toString() {
    StringBuffer buffer = new StringBuffer();
    buffer.append( inset );
    buffer.append( ", " );
    buffer.append( offsetX );
    buffer.append( ", " );
    buffer.append( offsetY );
    buffer.append( ", " );
    buffer.append( blur );
    buffer.append( ", " );
    buffer.append( spread );
    buffer.append( ", " );    
    buffer.append( color );
    buffer.append( ", " );
    buffer.append( opacity );
    return "QxShadow{ " + buffer.toString() + " }";
  }
}

Lines 1-5 Link Here

(-)src/org/eclipse/rwt/internal/theme/ThemeStoreWriter.java (-2 / +19 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009, 2010 EclipseSource and others. All rights reserved.	2	* Copyright (c) 2009, 2011 EclipseSource and others. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0 which accompanies this distribution,	4	* terms of the Eclipse Public License v1.0 which accompanies this distribution,
5	* and is available at http://www.eclipse.org/legal/epl-v10.html	5	* and is available at http://www.eclipse.org/legal/epl-v10.html
Lines 54-59 Link Here
54	JsonObject borderMap = new JsonObject();	54	JsonObject borderMap = new JsonObject();
55	JsonObject cursorMap = new JsonObject();	55	JsonObject cursorMap = new JsonObject();
56	JsonObject animationMap = new JsonObject();	56	JsonObject animationMap = new JsonObject();
		57	JsonObject shadowMap = new JsonObject();
57	QxType[] values = new QxType[ valueSet.size() ];	58	QxType[] values = new QxType[ valueSet.size() ];
58	valueSet.toArray( values );	59	valueSet.toArray( values );
59	for( int i = 0; i < values.length; i++ ) {	60	for( int i = 0; i < values.length; i++ ) {
Lines 94-100 Link Here
94	}	95	}
95	} else if( value instanceof QxColor ) {	96	} else if( value instanceof QxColor ) {
96	QxColor color = ( QxColor )value;	97	QxColor color = ( QxColor )value;
97	if( color.transparent ) {	98	if( color.isTransparent() ) {
98	colorMap.append( key, "undefined" );	99	colorMap.append( key, "undefined" );
99	} else {	100	} else {
100	colorMap.append( key, QxColor.toHtmlString( color.red,	101	colorMap.append( key, QxColor.toHtmlString( color.red,
Lines 137-142 Link Here
137	currentAnimationArray );	138	currentAnimationArray );
138	}	139	}
139	animationMap.append( key, animationObject );	140	animationMap.append( key, animationObject );
		141	} else if( value instanceof QxShadow ) {
		142	QxShadow shadow = ( QxShadow )value;
		143	if( shadow.equals( QxShadow.NONE ) ) {
		144	shadowMap.append( key, JsonValue.NULL );
		145	} else {
		146	JsonArray shadowArray = new JsonArray();
		147	shadowArray.append( shadow.inset );
		148	shadowArray.append( shadow.offsetX );
		149	shadowArray.append( shadow.offsetY );
		150	shadowArray.append( shadow.blur );
		151	shadowArray.append( shadow.spread );
		152	shadowArray.append( shadow.color );
		153	shadowArray.append( shadow.opacity );
		154	shadowMap.append( key, shadowArray );
		155	}
140	}	156	}
141	}	157	}
142	JsonObject valuesMap = new JsonObject();	158	JsonObject valuesMap = new JsonObject();
Lines 149-154 Link Here
149	valuesMap.append( "borders", borderMap );	165	valuesMap.append( "borders", borderMap );
150	valuesMap.append( "cursors", cursorMap );	166	valuesMap.append( "cursors", cursorMap );
151	valuesMap.append( "animations", animationMap );	167	valuesMap.append( "animations", animationMap );
		168	valuesMap.append( "shadows", shadowMap );
152	return valuesMap;	169	return valuesMap;
153	}	170	}
154		171

Lines 1-5 Link Here

(-)src/org/eclipse/rwt/internal/theme/css/PropertyResolver.java (-1 / +137 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2010 Innoopract Informationssysteme GmbH.	2	* Copyright (c) 2008, 2011 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 119-124 Link Here
119	result = readFloat( unit );	119	result = readFloat( unit );
120	} else if( isAnimationProperty( name ) ) {	120	} else if( isAnimationProperty( name ) ) {
121	result = readAnimation( unit );	121	result = readAnimation( unit );
		122	} else if( isShadowProperty( name ) ) {
		123	result = readShadow( unit );
122	} else {	124	} else {
123	throw new IllegalArgumentException( "Unknown property " + name );	125	throw new IllegalArgumentException( "Unknown property " + name );
124	}	126	}
Lines 183-188 Link Here
183	return result;	185	return result;
184	}	186	}
185		187
		188	static QxColor readColorWithAlpha( final LexicalUnit unit ) {
		189	QxColor result = null;
		190	int[] values = new int[ 3 ];
		191	float alpha = 1f;
		192	short type = unit.getLexicalUnitType();
		193	if( type == LexicalUnit.SAC_FUNCTION
		194	&& "rgba".equals( unit.getFunctionName() ) )
		195	{
		196	LexicalUnit nextUnit = unit.getParameters();
		197	boolean ok = nextUnit != null;
		198	boolean mixedTypes = false;
		199	short previousType = -1;
		200	int pos = 0;
		201	while( ok ) {
		202	type = nextUnit.getLexicalUnitType();
		203	if( pos == 0 \|\| pos == 2 \|\| pos == 4 ) {
		204	// color number
		205	if( type == LexicalUnit.SAC_INTEGER ) {
		206	values[ pos / 2 ] = normalizeRGBValue( nextUnit.getIntegerValue() );
		207	} else if( type == LexicalUnit.SAC_PERCENTAGE ) {
		208	float percentValue
		209	= normalizePercentValue( nextUnit.getFloatValue() );
		210	values[ pos / 2 ] = ( int )( 255 * percentValue / 100 );
		211	} else {
		212	ok = false;
		213	}
		214	mixedTypes = previousType != -1 && previousType != type;
		215	previousType = type;
		216	} else if( pos == 1 \|\| pos == 3 \|\| pos == 5 ) {
		217	// comma
		218	if( type != LexicalUnit.SAC_OPERATOR_COMMA ) {
		219	ok = false;
		220	}
		221	} else if( pos == 6 ) {
		222	// alpha number
		223	if( type == LexicalUnit.SAC_REAL ) {
		224	alpha = normalizeAlphaValue( nextUnit.getFloatValue() );
		225	} else {
		226	ok = false;
		227	}
		228	}
		229	pos++;
		230	nextUnit = nextUnit.getNextLexicalUnit();
		231	ok &= nextUnit != null && pos < 7 && !mixedTypes;
		232	}
		233	if( pos == 7 ) {
		234	result = QxColor.create( values[ 0 ], values[ 1 ], values[ 2 ], alpha );
		235	}
		236	}
		237	if( result == null ) {
		238	throw new IllegalArgumentException( "Failed to parse rgba color" );
		239	}
		240	return result;
		241	}
		242
186	static boolean isDimensionProperty( final String property ) {	243	static boolean isDimensionProperty( final String property ) {
187	return "spacing".equals( property )	244	return "spacing".equals( property )
188	\|\| "width".equals( property )	245	\|\| "width".equals( property )
Lines 771-776 Link Here
771	return result;	828	return result;
772	}	829	}
773		830
		831	static boolean isShadowProperty( final String property ) {
		832	return "box-shadow".equals( property );
		833	}
		834
		835	static QxShadow readShadow( final LexicalUnit unit ) {
		836	QxShadow result = null;
		837	boolean inset = false;
		838	Integer offsetX = null;
		839	Integer offsetY = null;
		840	int blur = 0;
		841	int spread = 0;
		842	QxColor color = QxColor.BLACK;
		843	LexicalUnit nextUnit = unit;
		844	short type = nextUnit.getLexicalUnitType();
		845	if( type == LexicalUnit.SAC_IDENT ) {
		846	String value = nextUnit.getStringValue();
		847	if( NONE.equals( value ) ) {
		848	result = QxShadow.NONE;
		849	} else if( INSET.equals( value ) ) {
		850	inset = true;
		851	}
		852	nextUnit = nextUnit.getNextLexicalUnit();
		853	}
		854	if( result == null ) {
		855	boolean ok = true;
		856	int pos = 0;
		857	while( nextUnit != null && ok ) {
		858	pos++;
		859	Integer nextValue = readSingleLengthUnit( nextUnit );
		860	ok &= nextValue != null && pos <= 4;
		861	if( ok ) {
		862	if( pos == 1 ) {
		863	offsetX = nextValue;
		864	} else if( pos == 2 ) {
		865	offsetY = nextValue;
		866	} else if( pos == 3 ) {
		867	blur = nextValue.intValue();
		868	} else if( pos == 4 ) {
		869	spread = nextValue.intValue();
		870	}
		871	nextUnit = nextUnit.getNextLexicalUnit();
		872	}
		873	}
		874	if( nextUnit != null ) {
		875	type = nextUnit.getLexicalUnitType();
		876	if( type == LexicalUnit.SAC_FUNCTION
		877	&& "rgba".equals( nextUnit.getFunctionName() ) )
		878	{
		879	color = readColorWithAlpha( nextUnit );
		880	} else {
		881	color = readColor( nextUnit );
		882	}
		883	}
		884	}
		885	if( offsetX != null && offsetY != null ) {
		886	result = QxShadow.create( inset,
		887	offsetX.intValue(),
		888	offsetY.intValue(),
		889	blur,
		890	spread,
		891	color );
		892	}
		893	if( result == null ) {
		894	throw new IllegalArgumentException( "Failed to parse shadow "
895	+ toString( unit ) );
896	}
897	return result;
898	}
899
774	private static Integer readSingleLengthUnit( final LexicalUnit unit ) {	900	private static Integer readSingleLengthUnit( final LexicalUnit unit ) {
775	Integer result = null;	901	Integer result = null;
776	short type = unit.getLexicalUnitType();	902	short type = unit.getLexicalUnitType();
Lines 795-800 Link Here
795	return result;	921	return result;
796	}	922	}
797		923
		924	private static float normalizeAlphaValue( final float input ) {
		925	float result = input;
		926	if( input < 0 ) {
		927	result = 0f;
		928	} else if( input > 1 ) {
		929	result = 1f;
		930	}
		931	return result;
		932	}
		933
798	private static float normalizePercentValue( final float input ) {	934	private static float normalizePercentValue( final float input ) {
799	float result = input;	935	float result = input;
800	if( input < 0f ) {	936	if( input < 0f ) {

Lines 1-5 Link Here

(-)src/org/eclipse/swt/internal/widgets/shellkit/Shell.default.css (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2010 Innoopract Informationssysteme GmbH.	2	* Copyright (c) 2008, 2011 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 18-23 Link Here
18	padding: 0px;	18	padding: 0px;
19	background-image: none;	19	background-image: none;
20	opacity: 1;	20	opacity: 1;
		21	box-shadow: none;
21	}	22	}
22		23
23	Shell[TITLE], Shell[BORDER] {	24	Shell[TITLE], Shell[BORDER] {

Lines 1-6 Link Here

(-)src/org/eclipse/swt/internal/widgets/shellkit/Shell.theme.xml (-3 / +6 lines)
1	<?xml version="1.0" encoding="UTF-8" ?>	1	<?xml version="1.0" encoding="UTF-8" ?>
2	<!--	2	<!--
3	Copyright (c) 2008, 2009 Innoopract Informationssysteme GmbH.	3	Copyright (c) 2008, 2011 Innoopract Informationssysteme GmbH.
4	All rights reserved. This program and the accompanying materials	4	All rights reserved. This program and the accompanying materials
5	are made available under the terms of the Eclipse Public License v1.0	5	are made available under the terms of the Eclipse Public License v1.0
6	which accompanies this distribution, and is available at	6	which accompanies this distribution, and is available at
Lines 35-42 Link Here
35	<property name="background-color"	35	<property name="background-color"
36	description="Background color for shells." />	36	description="Background color for shells." />
37		37
38	<property name="opacity"	38	<property name="opacity"
39	description="The opacity of the shell. A value between 0 and 1." />	39	description="The opacity of the shell. A value between 0 and 1." />
		40
		41	<property name="box-shadow"
		42	description="The shadow behind the shell." />
40		43
41	<style name="BORDER"	44	<style name="BORDER"
42	description="Indicates that the shell should have a border." />	45	description="Indicates that the shell should have a border." />

Lines 1-5 Link Here

(-)js/org/eclipse/swt/theme/ThemeStore.js (-2 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Innoopract Informationssysteme GmbH.	2	* Copyright (c) 2007, 2011 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 31-37 Link Here
31	colors : {},	31	colors : {},
32	borders : {},	32	borders : {},
33	cursors : {},	33	cursors : {},
34	animations : {}	34	animations : {},
		35	shadows : {}
35	};	36	};
36	this._cssValues = {};	37	this._cssValues = {};
37	this._statesMap = {	38	this._statesMap = {

Lines 168-174 Link Here

(-)js/org/eclipse/swt/theme/ThemeValues.js (-1 / +8 lines)
168	getCssAnimation : function( element, key ) {	168	getCssAnimation : function( element, key ) {
169	var vkey = this._store.getCssValue( element, this._states, key );	169	var vkey = this._store.getCssValue( element, this._states, key );
170	var values = this._store.getThemeValues();	170	var values = this._store.getThemeValues();
171	var result = values.animations[ vkey ];	171	var result = values.animations[ vkey ];
		172	return result;
		173	},
		174
		175	getCssShadow : function( element, key ) {
		176	var vkey = this._store.getCssValue( element, this._states, key );
		177	var values = this._store.getThemeValues();
		178	var result = values.shadows[ vkey ];
172	return result;	179	return result;
173	}	180	}
174		181




/*******************************************************************************
 * Copyright (c) 2007, 2011 Innoopract Informationssysteme GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

    }
  }

  public void testIllegalArguments_OutOfRangeAlpha() {
    try {
      QxColor.valueOf( "1, 2, 3, 1.01" );
      fail( "Exception expected" );
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testIllegalArguments_NegativeAlpha() {
    try {
      QxColor.valueOf( "1, 2, 3, -0.01" );
      fail( "Exception expected" );
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void test6HexNotation() {
    QxColor color1 = QxColor.valueOf( "#0023ff" );
    assertEquals( 0, color1.red );
    assertEquals( 35, color1.green );
    assertEquals( 255, color1.blue );
    assertEquals( 1f, color1.alpha, 0 );
    QxColor color2 = QxColor.valueOf( "#efeFEF" );
    assertEquals( 239, color2.red );
    assertEquals( 239, color2.green );

    assertEquals( 0, color1.red );
    assertEquals( 51, color1.green );
    assertEquals( 255, color1.blue );
    assertEquals( 1f, color1.alpha, 0 );
    QxColor color2 = QxColor.valueOf( "#ccc" );
    assertEquals( 204, color2.red );
    assertEquals( 204, color2.green );

    assertEquals( 255, color1.red );
    assertEquals( 0, color1.green );
    assertEquals( 0, color1.blue );
    assertEquals( 1f, color1.alpha, 0 );
    QxColor color2 = QxColor.valueOf( "blue" );
    assertEquals( 0, color2.red );
    assertEquals( 0, color2.green );

    assertEquals( 100, color.red );
    assertEquals( 23, color.green );
    assertEquals( 42, color.blue );
    assertEquals( 1f, color.alpha, 0 );
  }

  public void testCommaSeparatedValues_WithAlpha() {
    QxColor color = QxColor.valueOf( "100, 23, 42, 0.5" );
    assertEquals( 100, color.red );
    assertEquals( 23, color.green );
    assertEquals( 42, color.blue );
    assertEquals( 0.5, color.alpha, 0 );
  }

  public void testTransparent() {
    assertTrue( QxColor.TRANSPARENT.isTransparent() );
  }

  public void testShared() {


  public void testToString() {
    QxColor color = QxColor.valueOf( "100, 23, 42" );
    assertEquals( "QxColor{ 100, 23, 42, 1.0 }", color.toString() );
  }

  public void testToString_WithAlpha() {
    QxColor color = QxColor.valueOf( "100, 23, 42, 0.5" );
    assertEquals( "QxColor{ 100, 23, 42, 0.5 }", color.toString() );
  }

  public void testDefaultString() {
    QxColor color = QxColor.valueOf( "100, 23, 42" );
    assertEquals( "#64172a", color.toDefaultString() );
  }
  
  public void testDefaultString_Transparent() {
    QxColor color = QxColor.valueOf( "100, 23, 42, 0" );
    assertEquals( "transparent", color.toDefaultString() );
  }

  public void testDefaultString_WithAlpha() {
    QxColor color = QxColor.valueOf( "100, 23, 42, 0.5" );
    assertEquals( "rgba(100,23,42,0.5)", color.toDefaultString() );
  }

  public void testWithTurkishLocale() {
    Locale originalLocale = Locale.getDefault();




/*******************************************************************************
 * Copyright (c) 2011 EclipseSource and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution, 
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   EclipseSource - initial API and implementation
 ******************************************************************************/
package org.eclipse.rwt.internal.theme;

import junit.framework.TestCase;


public class QxShadow_Test extends TestCase {
  
  public void testIllegalArguments_Inset() {
    try {
      QxShadow.create( true, 10, 10, 0, 0, QxColor.BLACK );
      fail( "Exception expected" );
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testIllegalArguments_NegativeBlur() {
    try {
      QxShadow.create( false, 10, 10, -10, 0, QxColor.BLACK );
      fail( "Exception expected" );
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }
  
  public void testIllegalArguments_SpreadNotZero() {
    try {
      QxShadow.create( false, 10, 10, 0, 10, QxColor.BLACK );
      fail( "Exception expected" );
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }
  
  public void testIllegalArguments_NullColor() {
    try {
      QxShadow.create( false, 10, 10, 0, 0, null );
      fail( "Exception expected" );
    } catch( NullPointerException e ) {
      // expected
    }
  }

  public void testCreate_WithoutOpacity() {
    QxShadow shadow = QxShadow.create( false, 10, 10, 0, 0, QxColor.BLACK );
    assertNotNull( shadow );
    assertFalse( shadow.inset );
    assertEquals( 10, shadow.offsetX );
    assertEquals( 10, shadow.offsetY );
    assertEquals( 0, shadow.blur );
    assertEquals( 0, shadow.spread );
    assertEquals( QxColor.BLACK.toDefaultString(), shadow.color );
    assertEquals( 1f, shadow.opacity, 0 );
  }

  public void testCreate_WithOpacity() {
    QxColor color = QxColor.valueOf( "0, 0, 0, 0.5" );
    QxShadow shadow = QxShadow.create( false, 10, 10, 0, 0, color );
    assertNotNull( shadow );
    assertFalse( shadow.inset );
    assertEquals( 10, shadow.offsetX );
    assertEquals( 10, shadow.offsetY );
    assertEquals( 0, shadow.blur );
    assertEquals( 0, shadow.spread );
    assertEquals( QxColor.BLACK.toDefaultString(), shadow.color );
    assertEquals( 0.5, shadow.opacity, 0 );
  }

  public void testNoneShadow() {
    QxShadow shadow = QxShadow.NONE;
    assertFalse( shadow.inset );
    assertEquals( 0, shadow.offsetX );
    assertEquals( 0, shadow.offsetY );
    assertEquals( 0, shadow.blur );
    assertEquals( 0, shadow.spread );
    assertNull( shadow.color );
    assertEquals( 0, shadow.opacity, 0 );
  }

  public void testToString() {
    QxShadow shadow = QxShadow.create( false, 10, 10, 0, 0, QxColor.BLACK );
    String expected = "QxShadow{ false, 10, 10, 0, 0, #000000, 1.0 }";
    assertEquals( expected, shadow.toString() );
  }

  public void testToDefaultString() {
    QxColor color = QxColor.valueOf( "0, 0, 0, 0.5" );
    QxShadow shadow = QxShadow.create( false, 10, 10, 0, 0, color );
    String expected = "10px 10px 0px 0px rgba( 0, 0, 0, 0.5 )";
    assertEquals( expected, shadow.toDefaultString() );
  }

  public void testToDefaultString_NoneShadow() {
    QxShadow shadow = QxShadow.NONE;
    String expected = "none";
    assertEquals( expected, shadow.toDefaultString() );
  }

  public void testEquals() {
    QxShadow shadow1 = QxShadow.create( false, 10, 10, 0, 0, QxColor.BLACK );
    QxShadow shadow2 = QxShadow.create( false, 10, 10, 0, 0, QxColor.BLACK );
    assertTrue( shadow1.equals( shadow2 ) );
  } 
}




/*******************************************************************************
 * Copyright (c) 2009, 2011 EclipseSource and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html

    expected = "\"cd56ce7d\": [ \"cd56ce7d\", 50, 100 ]";
    assertTrue( output.indexOf( expected ) != -1 );
    // conditional colors
    expected = "\"color\": [ [ [ \"[BORDER\" ], "
             + "\"400339c0\" ], [ [], \"3fe41900\" ] ]";
    assertTrue( output.indexOf( expected ) != -1 );
    // conditional background-images
    expected = "\"background-image\": "

                      + "\"slideIn\": [ 2000, \"easeIn\" ],\n"
                      + "\"slideOut\": [ 2000, \"easeOut\" ]\n"
                      + "}\n"
                      + "},\n";
    assertTrue( output.indexOf( expected ) != -1 );
    expected = "\"Menu\": {\n"
               + "\"animation\": [ [ [], \"2e5f3d63\" ] ]\n"

    assertTrue( output.indexOf( expected ) != -1 );
  }

  public void testWriteShadow() throws Exception {
    ThemeCssElement element = new ThemeCssElement( "Shell" );
    element.addProperty( "box-shadow" );
    IThemeCssElement[] elements = new IThemeCssElement[] { element };
    ThemeStoreWriter storeWriter = new ThemeStoreWriter( elements );
    String themeId = "myTheme";
    String cssCode
      = "Shell { box-shadow: 10px 10px 3px 0 rgba( 0, 0, 0, 0.5 ); }\n";
    ResourceLoader loader
      = ThemeTestUtil.createResourceLoader( Fixture.class );
    ThemeTestUtil.registerCustomTheme( themeId, cssCode, loader );
    Theme theme = ThemeManager.getInstance().getTheme( themeId );
    storeWriter.addTheme( theme, true );
    String output = storeWriter.createJs();
    String expected = "\"shadows\": {\n"
      + "\"2aedfabd\": [ false, 10, 10, 3, 0, \"#000000\", 0.5 ]\n"
      + "}\n";
    assertTrue( output.indexOf( expected ) != -1 );
    expected = "\"Shell\": {\n"
               + "\"box-shadow\": [ [ [], \"2aedfabd\" ] ]\n"
               + "}";
    assertTrue( output.indexOf( expected ) != -1 );
  }

  protected void setUp() throws Exception {
    Fixture.setUp();
    Fixture.fakeNewRequest();




/*******************************************************************************
 * Copyright (c) 2008, 2011 Innoopract Informationssysteme GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

    }
  }

  public void testColorWithAlpha() throws Exception {
    String input = "rgba( 1, 2, 3, 0.25 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.red );
    assertEquals( 2, result.green );
    assertEquals( 3, result.blue );
    assertEquals( 0.25, result.alpha, 0 );
  }

  public void testColorWithAlpha_Percents() throws Exception {
    String input = "rgba( 0%, 50%, 100%, 0.25 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 0, result.red );
    assertEquals( 127, result.green );
    assertEquals( 255, result.blue );
    assertEquals( 0.25, result.alpha, 0 );
  }
  
  public void testColorWithAlpha_NoTransparency() throws Exception {
    String input = "rgba( 0, 0, 0, 1 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertSame( QxColor.BLACK, result );
  }

  public void testColorWithAlpha_NormalizeNegativeAlpha() throws Exception {
    String input = "rgba( 1, 2, 3, -0.1 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.red );
    assertEquals( 2, result.green );
    assertEquals( 3, result.blue );
    assertEquals( 0f, result.alpha, 0 );
  }

  public void testColorWithAlpha_NormalizePositiveAlpha() throws Exception {
    String input = "rgba( 1, 2, 3, 1.1 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.red );
    assertEquals( 2, result.green );
    assertEquals( 3, result.blue );
    assertEquals( 1f, result.alpha, 0 );
  }

  public void testColorWithAlpha_NormalizeColorValue() throws Exception {
    String input = "rgba( -10, 127, 300, 0.25 )";
    QxColor result
      = PropertyResolver.readColorWithAlpha( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 0, result.red );
    assertEquals( 127, result.green );
    assertEquals( 255, result.blue );
    assertEquals( 0.25, result.alpha, 0 );
  }

  public void testColorWithAlpha_MixedValues() throws Exception {
    String input = "rgba( 0%, 50, 100, 0.25 )";
    try {
      PropertyResolver.readColorWithAlpha( parseProperty( input ) );
      fail();
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testDimension() throws Exception {
    QxDimension zero = PropertyResolver.readDimension( parseProperty( "0px" ) );
    assertNotNull( zero );

    }
  }

  public void testShadow_XYOffsetOnlyNotation() throws Exception {
    String input = "1px 2px";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 0, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#000000", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_OffsetXYBlurNotation() throws Exception {
    String input = "1px 2px 3px";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 3, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#000000", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_XYOffsetBlurSpreadNotation() throws Exception {
    String input = "1px 2px 0 0";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 0, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#000000", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_FullNotation_NamedColor() throws Exception {
    String input = "1px 2px 0px 0 red";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 0, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#ff0000", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_FullNotation_HexColor() throws Exception {
    String input = "1px 2px 0px 0 #FF0000";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 0, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#ff0000", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_FullNotation_RgbColor() throws Exception {
    String input = "1px 2px 3px 0 rgb( 1, 2, 3 )";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 3, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#010203", result.color );
    assertEquals( 1f, result.opacity, 0 );
  }

  public void testShadow_FullNotation_RgbaColor() throws Exception {
    String input = "1px 2px 0px 0 rgba( 1, 2, 3, 0.25 )";
    QxShadow result = PropertyResolver.readShadow( parseProperty( input ) );
    assertNotNull( result );
    assertEquals( 1, result.offsetX );
    assertEquals( 2, result.offsetY );
    assertEquals( 0, result.blur );
    assertEquals( 0, result.spread );
    assertEquals( "#010203", result.color );
    assertEquals( 0.25, result.opacity, 0 );
  }

  public void testShadow_WithoutOffsetY() throws Exception {
    try {
      PropertyResolver.readShadow( parseProperty( "1px" ) );
      fail();
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testShadow_MissingRgbaParameters() throws Exception {
    String input = "1px 2px 0px 0 rgba( 1, 2, 0.25 )";
    try {
      PropertyResolver.readShadow( parseProperty( input ) );
      fail();
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testShadow_NonZeroSpread() throws Exception {
    String input = "1px 2px 3px 3px rgba( 1, 2, 3, 0.25 )";
    try {
      PropertyResolver.readShadow( parseProperty( input ) );
      fail();
    } catch( IllegalArgumentException e ) {
      // expected
    }
  }

  public void testIsColorProperty() {
    assertFalse( PropertyResolver.isColorProperty( "border" ) );
    assertTrue( PropertyResolver.isColorProperty( "color" ) );

    assertTrue( PropertyResolver.isAnimationProperty( "animation" ) );
  }

  public void testIsShadowProperty() {
    assertTrue( PropertyResolver.isShadowProperty( "box-shadow" ) );
  }

  public void testResolveProperty() throws Exception {
    LexicalUnit unit = parseProperty( "white" );
    QxType value = PropertyResolver.resolveProperty( "color", unit, null );

Return to bug 324436

Lines 1-5 Link Here

(-)src/org/eclipse/rwt/internal/theme/QxColor.java (-17 / +87 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2008 Innoopract Informationssysteme GmbH.	2	* Copyright (c) 2007, 2011 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Innoopract Informationssysteme GmbH - initial API and implementation	9	* Innoopract Informationssysteme GmbH - initial API and implementation
		10	* EclipseSource - ongoing development
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.rwt.internal.theme;	13	package org.eclipse.rwt.internal.theme;
Lines 24-32 Link Here
24		25
25	private static final Map NAMED_COLORS = new HashMap();	26	private static final Map NAMED_COLORS = new HashMap();
26		27
27	public static final QxColor BLACK = new QxColor( 0, 0, 0 );	28	public static final QxColor BLACK = new QxColor( 0, 0, 0, 1f );
28		29
29	public static final QxColor WHITE = new QxColor( 255, 255, 255 );	30	public static final QxColor WHITE = new QxColor( 255, 255, 255, 1f );
30		31
31	public static final QxColor TRANSPARENT = new QxColor();	32	public static final QxColor TRANSPARENT = new QxColor();
32		33
Lines 35-42 Link Here
35	public final int green;	36	public final int green;
36		37
37	public final int blue;	38	public final int blue;
38		39
39	public final boolean transparent;	40	public final float alpha;
40		41
41	static {	42	static {
42	// register 16 standard HTML colors	43	// register 16 standard HTML colors
Lines 62-75 Link Here
62	this.red = 0;	63	this.red = 0;
63	this.green = 0;	64	this.green = 0;
64	this.blue = 0;	65	this.blue = 0;
65	this.transparent = true;	66	this.alpha = 0f;
66	}	67	}
67		68
68	private QxColor( final int red, final int green, final int blue ) {	69	private QxColor( final int red,
		70	final int green,
		71	final int blue,
		72	final float alpha )
		73	{
69	this.red = red;	74	this.red = red;
70	this.green = green;	75	this.green = green;
71	this.blue = blue;	76	this.blue = blue;
72	this.transparent = false;	77	this.alpha = alpha;
73	}	78	}
74		79
75	public static QxColor create( final int red, final int green, final int blue )	80	public static QxColor create( final int red, final int green, final int blue )
Lines 80-89 Link Here
80	} else if( red == 255 && green == 255 && blue == 255 ) {	85	} else if( red == 255 && green == 255 && blue == 255 ) {
81	result = WHITE;	86	result = WHITE;
82	} else {	87	} else {
83	result = new QxColor( red, green, blue );	88	result = new QxColor( red, green, blue, 1f );
84	}	89	}
85	return result;	90	return result;
86	}	91	}
		92
		93	public static QxColor create( final int red,
		94	final int green,
		95	final int blue,
		96	final float alpha )
		97	{
		98	checkAlpha( alpha );
		99	QxColor result;
		100	if( alpha == 1f ) {
		101	result = create( red, green, blue );
		102	} else {
		103	result = new QxColor( red, green, blue, alpha );
		104	}
		105	return result;
		106	}
		107
		108	private static void checkAlpha( final float alpha ) {
		109	if( alpha < 0 \|\| alpha > 1 ) {
		110	String msg = "Alpha out of range [ 0, 1 ]: " + alpha;
		111	throw new IllegalArgumentException( msg );
		112	}
		113	}
87		114
88	public static QxColor valueOf( final String input ) {	115	public static QxColor valueOf( final String input ) {
89	QxColor result;	116	QxColor result;
Lines 94-99 Link Here
94	result = TRANSPARENT;	121	result = TRANSPARENT;
95	} else {	122	} else {
96	int red, green, blue;	123	int red, green, blue;
		124	float alpha = 1f;
97	String lowerCaseInput = input.toLowerCase( Locale.ENGLISH );	125	String lowerCaseInput = input.toLowerCase( Locale.ENGLISH );
98	if( input.startsWith( "#" ) ) {	126	if( input.startsWith( "#" ) ) {
99	try {	127	try {
Lines 124-134 Link Here
124	blue = values[ 2 ];	152	blue = values[ 2 ];
125	} else {	153	} else {
126	String[] parts = input.split( "\\s,\\s" );	154	String[] parts = input.split( "\\s,\\s" );
127	if( parts.length == 3 ) {	155	if( parts.length >= 3 && parts.length <= 4 ) {
128	try {	156	try {
129	red = Integer.parseInt( parts[ 0 ] );	157	red = Integer.parseInt( parts[ 0 ] );
130	green = Integer.parseInt( parts[ 1 ] );	158	green = Integer.parseInt( parts[ 1 ] );
131	blue = Integer.parseInt( parts[ 2 ] );	159	blue = Integer.parseInt( parts[ 2 ] );
		160	if( parts.length == 4 ) {
		161	alpha = Float.parseFloat( parts[ 3 ] );
		162	}
132	} catch( final NumberFormatException e ) {	163	} catch( final NumberFormatException e ) {
133	String pattern = "Illegal number format in color definition ''{0}''";	164	String pattern = "Illegal number format in color definition ''{0}''";
134	Object[] arguments = new Object[] { input };	165	Object[] arguments = new Object[] { input };
Lines 142-154 Link Here
142	throw new IllegalArgumentException( message );	173	throw new IllegalArgumentException( message );
143	}	174	}
144	}	175	}
145	result = create( red, green, blue );	176	result = create( red, green, blue, alpha );
146	}	177	}
147	return result;	178	return result;
148	}	179	}
149		180
		181	public boolean isTransparent() {
		182	return alpha == 0f;
		183	}
		184
150	public String toDefaultString() {	185	public String toDefaultString() {
151	return transparent ? TRANSPARENT_STR : toHtmlString( red, green, blue );	186	String result;
		187	if( isTransparent() ) {
		188	result = TRANSPARENT_STR;
		189	} else if( alpha == 1f ) {
		190	result = toHtmlString( red, green, blue );
		191	} else {
		192	result = toRgbaString( red, green, blue, alpha );
		193	}
		194	return result;
152	}	195	}
153		196
154	public boolean equals( final Object obj ) {	197	public boolean equals( final Object obj ) {
Lines 159-176 Link Here
159	QxColor other = ( QxColor )obj;	202	QxColor other = ( QxColor )obj;
160	result = other.red == red	203	result = other.red == red
161	&& other.green == green	204	&& other.green == green
162	&& other.blue == blue;	205	&& other.blue == blue
		206	&& other.alpha == alpha;
163	}	207	}
164	return result;	208	return result;
165	}	209	}
166		210
167	public int hashCode() {	211	public int hashCode() {
168	return transparent ? -1 : red + green * 256 + blue * 65536;	212	int result = -1;
		213	if( !isTransparent() ) {
		214	result = 41;
		215	result += 19 * result + red;
		216	result += 19 * result + green;
		217	result += 19 * result + blue;
		218	result += 19 * result + Float.floatToIntBits( alpha );
		219	}
		220	return result;
169	}	221	}
170		222
171	public String toString() {	223	public String toString() {
172	String colors = red + ", " + green + ", " + blue;	224	String colors = red + ", " + green + ", " + blue + ", " + alpha;
173	return "QxColor{ " + ( transparent ? TRANSPARENT_STR : colors ) + " }";	225	return "QxColor{ " + ( isTransparent() ? TRANSPARENT_STR : colors ) + " }";
174	}	226	}
175		227
176	public static String toHtmlString( final int red,	228	public static String toHtmlString( final int red,
Lines 187-193 Link Here
187		239
188	public static Color createColor( final QxColor color ) {	240	public static Color createColor( final QxColor color ) {
189	Color result = null;	241	Color result = null;
190	if( !color.transparent ) {	242	if( color.alpha == 1f ) {
191	result = Graphics.getColor( color.red, color.green, color.blue );	243	result = Graphics.getColor( color.red, color.green, color.blue );
192	}	244	}
193	return result;	245	return result;
Lines 197-200 Link Here
197	String hex = Integer.toHexString( value );	249	String hex = Integer.toHexString( value );
198	return hex.length() == 1 ? "0" + hex : hex;	250	return hex.length() == 1 ? "0" + hex : hex;
199	}	251	}
		252
		253	private static String toRgbaString( final int red,
		254	final int green,
		255	final int blue,
		256	final float alpha )
		257	{
		258	StringBuffer sb = new StringBuffer();
		259	sb.append( "rgba(" );
		260	sb.append( red );
		261	sb.append( "," );
		262	sb.append( green );
		263	sb.append( "," );
		264	sb.append( blue );
		265	sb.append( "," );
		266	sb.append( alpha );
		267	sb.append( ")" );
		268	return sb.toString();
		269	}
200	}	270	}

Added Link Here

(-)src/org/eclipse/rwt/internal/theme/QxShadow.java (+158 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 EclipseSource and others. All rights reserved.
3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0 which accompanies this distribution,
5	* and is available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Contributors:
8	* EclipseSource - initial API and implementation
9	******************************************************************************/
10	package org.eclipse.rwt.internal.theme;
11
12
13	public class QxShadow implements QxType {
14
15	public static final QxShadow NONE
16	= new QxShadow( false, 0 , 0, 0, 0, null, 0 );
17
18	public final boolean inset;
19	public final int offsetX;
20	public final int offsetY;
21	public final int blur;
22	public final int spread;
23	public final String color;
24	public final float opacity;
25
26	private QxShadow( final boolean inset,
27	final int offsetX,
28	final int offsetY,
29	final int blur,
30	final int spread,
31	final String color,
32	final float opacity )
33	{
34	this.inset = inset;
35	this.offsetX = offsetX;
36	this.offsetY = offsetY;
37	this.blur = blur;
38	this.spread = spread;
39	this.color = color;
40	this.opacity = opacity;
41	}
42
43	public static QxShadow create( final boolean inset,
44	final int offsetX,
45	final int offsetY,
46	final int blur,
47	final int spread,
48	final QxColor color )
49	{
50	String msg;
51	if( inset ) {
52	msg = "Shadow \"inset\" keyword is not supported";
53	throw new IllegalArgumentException( msg );
54	}
55	if( blur < 0 ) {
56	msg = "Shadow blur distance can't be negative";
57	throw new IllegalArgumentException( msg );
58	}
59	if( spread != 0 ) {
60	msg = "Shadow spread distance is not supported";
61	throw new IllegalArgumentException( msg );
62	}
63	if( color == null ) {
64	throw new NullPointerException( "null argument" );
65	}
66	String htmlColor = QxColor.toHtmlString( color.red,
67	color.green,
68	color.blue );
69	return new QxShadow( inset,
70	offsetX,
71	offsetY,
72	blur,
73	spread,
74	htmlColor,
75	color.alpha );
76	}
77
78	public boolean equals( final Object obj ) {
79	boolean result = false;
80	if( obj == this ) {
81	result = true;
82	} else if( obj instanceof QxShadow ) {
83	QxShadow other = ( QxShadow )obj;
84	result = other.inset == inset
85	&& other.offsetX == offsetX
86	&& other.offsetY == offsetY
87	&& other.blur == blur
88	&& other.spread == spread
89	&& ( color == null
90	? other.color == null
91	: color.equals( other.color ) )
92	&& other.opacity == opacity;
93	}
94	return result;
95	}
96
97	public int hashCode() {
98	int result = 17;
99	result += 11 * result + offsetX;
100	result += 11 * result + offsetY;
101	result += 11 * result + blur;
102	result += 11 * result + spread;
103	if( color != null ) {
104	result += 11 * result + color.hashCode();
105	}
106	result += 11 * result + Float.floatToIntBits( opacity );
107	result += inset ? 0 : 11 * result + 13;
108	return result;
109	}
110
111	public String toDefaultString() {
112	StringBuffer buffer = new StringBuffer();
113	if( color == null ) {
114	buffer.append( "none" );
115	} else {
116	if( inset ) {
117	buffer.append( "inset " );
118	}
119	buffer.append( offsetX );
120	buffer.append( "px " );
121	buffer.append( offsetY );
122	buffer.append( "px " );
123	buffer.append( blur );
124	buffer.append( "px " );
125	buffer.append( spread );
126	buffer.append( "px " );
127	buffer.append( "rgba( " );
128	QxColor qxColor = QxColor.valueOf( color );
129	buffer.append( qxColor.red );
130	buffer.append( ", " );
131	buffer.append( qxColor.green );
132	buffer.append( ", " );
133	buffer.append( qxColor.blue );
134	buffer.append( ", " );
135	buffer.append( opacity );
136	buffer.append( " )" );
137	}
138	return buffer.toString();
139	}
140
141	public String toString() {
142	StringBuffer buffer = new StringBuffer();
143	buffer.append( inset );
144	buffer.append( ", " );
145	buffer.append( offsetX );
146	buffer.append( ", " );
147	buffer.append( offsetY );
148	buffer.append( ", " );
149	buffer.append( blur );
150	buffer.append( ", " );
151	buffer.append( spread );
152	buffer.append( ", " );
153	buffer.append( color );
154	buffer.append( ", " );
155	buffer.append( opacity );
156	return "QxShadow{ " + buffer.toString() + " }";
157	}
158	}