advancedcolorpicker.mxml

Flex2StyleExplorer form Adobe

			{
				if ( isNaN(value) )
					return;
					
				lightness = value/100;
				var rgb:Array = hsl2rgb(hue, saturation, lightness);
				red = rgb[0];
				green = rgb[1];
				blue = rgb[2];
				dispatchEvent(new Event("colorChanged"));
			}
			
			private function set displayRed(value:Number):void
			{
				if ( isNaN(value) )
					return;
					
				red = value/255;
				var hsl:Array = rgb2hsl(red, green, blue);
				hue = hsl[0];
				saturation = hsl[1];
				lightness = hsl[2];
				dispatchEvent(new Event("colorChanged"));
			}
			
			private function set displayGreen(value:Number):void
			{
				if ( isNaN(value) )
					return;
					
				green = value/255;
				var hsl:Array = rgb2hsl(red, green, blue);
				hue = hsl[0];
				saturation = hsl[1];
				lightness = hsl[2];
				dispatchEvent(new Event("colorChanged"));
			}
			
			private function set displayBlue(value:Number):void
			{
				if ( isNaN(value) )
					return;
					
				blue = value/255;
				var hsl:Array = rgb2hsl(red, green, blue);
				hue = hsl[0];
				saturation = hsl[1];
				lightness = hsl[2];
				dispatchEvent(new Event("colorChanged"));
			}
			
			public function set hex(value:String):void
			{
				fromHex(value);
				dispatchEvent(new Event("colorChanged"));
			}
			
			private function fromHex(value:String):void
       		{
       			if ( value.indexOf("#") == 0 )
       				value = value.substr(1);
       				
       			while ( value.length < 6 )
       				value = "0"+value;
       				
       			if ( value.length > 6 )
       				value = value.substr(0,6);
       				
       			red = parseInt( value.substr(0,2), 16 ) / 255;
       			green = parseInt( value.substr(2,2), 16 ) / 255;
       			blue = parseInt( value.substr(4,2), 16 ) / 255;
       			
                var hsb:Array = rgb2hsl(red, green, blue);
                hue = hsb[0];
                saturation = hsb[1];
                lightness = hsb[2];
       		}
       		
       		private function handleHexChange():void
       		{
       			hex = t_hex.text;
       		}
			
			private function toHex(value:Number):String
       		{
       			if ( isNaN(value) )
       				return "00";
       				
       			value = Math.round(Math.max(Math.min(value, 255), 0));
       			
       			var mask:String = "0123456789ABCDEF";
       			
       			var pos1:Number = (value-(value%16))/16;
       			var pos2:Number = value%16;
       			
       			return mask.charAt(pos1) + mask.charAt(pos2);
       		}
       		
       		private function updatePickerLocation():void
			{
				switch ( whatColorSpace )
				{
					case CS_HUE:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height*hue) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height*hue) + 2;
						pickerHandle.x = Math.round(maincp.width*saturation);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*lightness));
						break;
						
					case CS_SATURATION:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height-(subcp.height*saturation)) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height-(subcp.height*saturation)) + 2;
						pickerHandle.x = Math.round(maincp.width*hue);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*lightness));
						break;
						
					case CS_LIGHTNESS:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height-(subcp.height*lightness)) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height-(subcp.height*lightness)) + 2;
						pickerHandle.x = Math.round(maincp.width*hue);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*saturation));
						break;
						
					case CS_RED:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height-(subcp.height*red)) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height-(subcp.height*red)) + 2;
						pickerHandle.x = Math.round(maincp.width*blue);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*green));
						break;
						
					case CS_GREEN:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height-(subcp.height*green)) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height-(subcp.height*green)) + 2;
						pickerHandle.x = Math.round(maincp.width*blue);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*red));
						break;
						
					case CS_BLUE:
						pickerHandleLeft.y = subcp.parent.y+(subcp.height-(subcp.height*blue)) + 2;
						pickerHandleRight.y = subcp.parent.y+(subcp.height-(subcp.height*blue)) + 2;
						pickerHandle.x = Math.round(maincp.width*red);
						pickerHandle.y = Math.round(maincp.height - (maincp.height*green));
						break;
				}
			}       		
			
			private function changeColorSpace(what:String):void
			{
				whatColorSpace = what;
				
				switch ( what )
				{
					case CS_HUE:
						updateColorSpace = drawHueColorspace;
						updateColorSpace2 = drawHueColorspace2;
						break;
						
					case CS_SATURATION:
						updateColorSpace = drawSaturationColorspace;
						updateColorSpace2 = drawSaturationColorspace2;
						break;
						
					case CS_LIGHTNESS:
						updateColorSpace = drawLightnessColorspace;
						updateColorSpace2 = drawLightnessColorspace2;
						break;
						
					case CS_RED:
						updateColorSpace = drawRedColorspace;
						updateColorSpace2 = drawRedColorspace2;
						break;
						
					case CS_GREEN:
						updateColorSpace = drawGreenColorspace;
						updateColorSpace2 = drawGreenColorspace2;
						break;
						
					case CS_BLUE:
						updateColorSpace = drawBlueColorspace;
						updateColorSpace2 = drawBlueColorspace2;
						break;
				}
				
				updatePickerLocation();
				updateColorSpace();
				updateColorSpace2();	
				bringToFront(pickerHandle);
			}
			
			private function drawHueColorspace():void
			{		
				if ( !maincp.contains(whiteArea) )
				{
					if ( maincp.contains(blackArea) )
						maincp.removeChild(blackArea);
						
					maincp.addChild(whiteArea);
				}
					
				if ( !maincp.contains(blackArea) )
					maincp.addChild(blackArea);
					
				var w:Number = maincp.width;
				var h:Number = maincp.height;
				
				var rgb:Array = hsl2rgb(hue, 1, 1);
				colorArea.graphics.clear();
				colorArea.graphics.beginFill(rgb2int(rgb[0], rgb[1], rgb[2]));
				colorArea.graphics.drawRect(0, 0, w, h);
				
                var matrix:Matrix = new Matrix();
                matrix.createGradientBox(w, h, 0, 0, 0);
                whiteArea.graphics.clear();
                whiteArea.graphics.beginGradientFill(GradientType.LINEAR, [0xFFFFFF, 0x000000], [1, 1], [0, 255], matrix);
                whiteArea.graphics.drawRect(0, 0, w, h);
                whiteArea.blendMode = "screen";

                matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
                blackArea.graphics.clear();
                blackArea.graphics.beginGradientFill(GradientType.LINEAR, [0xFFFFFF, 0x000000], [1, 1], [0, 255], matrix);
                blackArea.graphics.drawRect(0, 0, w, h);
                blackArea.blendMode = "multiply";
			}
			
			private function drawHueColorspace2():void
			{
				var w:Number = subcp.width;
				var h:Number = subcp.height;
				
				colorArea2.graphics.clear();
				for ( var y:int=0; y<h; y++ )
				{
					var drawHue:Number = (y/h);
					var rgb:Array = hsl2rgb(drawHue, 1, 1);
					var color:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
					colorArea2.graphics.beginFill(color);
					colorArea2.graphics.drawRect(0, y, w, 1);
				}
			}
			
			private function drawSaturationColorspace():void
			{
				if ( maincp.contains(whiteArea) )
					maincp.removeChild(whiteArea);
					
				if ( !maincp.contains(blackArea) )
					maincp.addChild(blackArea);
					
				var w:Number = maincp.width;
				var h:Number = maincp.height;
				
				colorArea.graphics.clear();
				for ( var i:int=0; i<w; i++ )
				{
					var drawHue:Number = (1/255)*i;
					var rgb:Array = hsl2rgb(drawHue, saturation, 1);
					colorArea.graphics.beginFill(rgb2int(rgb[0], rgb[1], rgb[2]));
					colorArea.graphics.drawRect(i, 0, 1, h);
				}

				var matrix:Matrix = new Matrix();
                matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
                blackArea.graphics.clear();
                blackArea.graphics.beginGradientFill(GradientType.LINEAR, [0xFFFFFF, 0x000000], [1, 1], [0, 255], matrix);
                blackArea.graphics.drawRect(0, 0, w, h);
                blackArea.blendMode = "multiply";
			}
			
			private function drawSaturationColorspace2():void
			{
				var w:Number = subcp.width;
				var h:Number = subcp.height;
				
				var rgb:Array = hsl2rgb(hue, 1, lightness);
				var color1:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
				
				rgb = hsl2rgb(hue, 0, lightness);
				var color2:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea2.graphics.clear();
				colorArea2.graphics.beginGradientFill(GradientType.LINEAR, [color1, color2], [1, 1], [0, 255], matrix);
				colorArea2.graphics.drawRect(0, 0, w, h);
			}
			
			private function drawLightnessColorspace():void
			{
				if ( maincp.contains(blackArea) )
					maincp.removeChild(blackArea);
					
				if ( maincp.contains(whiteArea) )
					maincp.removeChild(whiteArea);
				
				var w:Number = maincp.width;
				var h:Number = maincp.height;
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea.graphics.clear();
				for ( var i:int=0; i<w; i++ )
				{
					var drawHue:Number = (1/255)*i;
					var rgb:Array = hsl2rgb(drawHue, 1, lightness);
					var color1:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
					rgb = hsl2rgb(0, 0, lightness);
					var color2:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
					
					colorArea.graphics.beginGradientFill(GradientType.LINEAR, [color1, color2], [1, 1], [0, 255], matrix);
					colorArea.graphics.drawRect(i, 0, 1, h);
				}
			}
			
			private function drawLightnessColorspace2():void
			{
				var w:Number = subcp.width;
				var h:Number = subcp.height;
				
				var rgb:Array = hsl2rgb(hue, saturation, 1);
				var color:uint = rgb2int(rgb[0], rgb[1], rgb[2]);
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea2.graphics.clear();
				colorArea2.graphics.beginGradientFill(GradientType.LINEAR, [color, 0x000000], [1, 1], [0, 255], matrix);
				colorArea2.graphics.drawRect(0, 0, w, h);
			}
			
			private function drawRedColorspace():void
			{
				if ( maincp.contains(whiteArea) )
					maincp.removeChild(whiteArea);
					
				if ( maincp.contains(blackArea) )
					maincp.removeChild(blackArea);
				
				var w:Number = maincp.width;
				var h:Number = maincp.height;
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea.graphics.clear();
				for ( var x:int=0; x<w; x++ )
				{
					var endColor:uint = rgb2int(red, 0, x/w);
					var startColor:uint = rgb2int(red, 1, x/w);
					colorArea.graphics.beginGradientFill(GradientType.LINEAR, [startColor, endColor], [1, 1], [0, 255], matrix);
					colorArea.graphics.drawRect(x, 0, 1, h);
				}
			}
			
			private function drawRedColorspace2():void
			{
				var w:Number = subcp.width;
				var h:Number = subcp.height;
				
				var color1:uint = rgb2int(1, green, blue);
				var color2:uint = rgb2int(0, green, blue);
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea2.graphics.clear();
				colorArea2.graphics.beginGradientFill(GradientType.LINEAR, [color1, color2], [1, 1], [0, 255], matrix);
				colorArea2.graphics.drawRect(0, 0, w, h);
			}
			
			private function drawGreenColorspace():void
			{
				if ( maincp.contains(whiteArea) )
					maincp.removeChild(whiteArea);
					
				if ( maincp.contains(blackArea) )
					maincp.removeChild(blackArea);
				
				var w:Number = maincp.width;
				var h:Number = maincp.height;
				
				var matrix:Matrix = new Matrix();
				matrix.createGradientBox(w, h, Math.PI/2, 0, 0);
				
				colorArea.graphics.clear();
				for ( var x:int=0; x<w; x++ )
				{
					var endColor:uint = rgb2int(0, green, x/w);
					var startColor:uint = rgb2int(1, green, x/w);
					colorArea.graphics.beginGradientFill(GradientType.LINEAR, [startColor, endColor], [1, 1], [0, 255], matrix);
					colorArea.graphics.drawRect(x, 0, 1, h);
				}
			}
			
			private function drawGreenColorspace2():void
			{