topical media & game development

topical media & game development

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

student-ar-fl-controls-ColorPicker.ax

student-ar-fl-controls-ColorPicker.ax [swf] flex


  // Copyright 2007. Adobe Systems Incorporated. All Rights Reserved.
  package fl.controls {
  
          import fl.core.UIComponent;
          import fl.core.InvalidationType;
          import fl.controls.BaseButton;
          import fl.controls.TextInput;
          import fl.controls.TextArea;
          import fl.events.ComponentEvent;
          import fl.events.@fileEvent;
          import fl.managers.IFocusManager;
          import fl.managers.IFocusManagerComponent;
          import flash.events.MouseEvent;
          import flash.events.Event;
          import flash.events.KeyboardEvent;
          import flash.events.FocusEvent;
          import flash.display.DisplayObject;
          import flash.display.Graphics;
          import flash.display.Sprite;
          import flash.geom.ColorTransform;
          import flash.geom.Point;
          import flash.geom.Rectangle;
          import flash.text.TextField;
          import flash.text.TextFieldType;
          import flash.text.TextFormat;
          import flash.ui.Keyboard;
          import flash.system.IME;
  
          //--------------------------------------
          //  Events
          //--------------------------------------


  
          [Event(name="open", type="flash.events.Event")]


  
          [Event(name="close", type="flash.events.Event")]


  
          [Event(name="change", type="fl.events.@fileEvent")]


  
          [Event(name="itemRollOver", type="fl.events.@fileEvent")]


  
          [Event(name="itemRollOut", type="fl.events.@fileEvent")]


  
          [Event(name="enter", type="fl.events.@fileEvent")]
  
          //--------------------------------------
          //  Styles
          //--------------------------------------


  
          [Style(name="swatchPadding", type="Number", format="Length")]


  
          [Style(name="disabledSkin", type="Class")]


  
          [Style(name="textPadding", type="Number", format="Length")]


  
          [Style(name="overSkin", type="Class")]


  
          [Style(name="backgroundPadding", type="Number", format="Length")]


  
          [Style(name="colorWell", type="Class")]


  
          [Style(name="downSkin", type="Class")]


  
          [Style(name="textFieldSkin", type="Class")]


  
          [Style(name="background", type="Class")]


  
          [Style(name="swatchSkin", type="Class")]


  
          [Style(name="swatchSelectedSkin", type="Class")]


  
          [Style(name="swatchWidth", type="Number", format="Length")]


  
          [Style(name="swatchHeight", type="Number", format="Length")]


  
          [Style(name="columnCount", type="Number", format="Length")]


  
          [Style(name="upSkin", type="Class")]


  
          [Style(name="embedFonts", type="Boolean")]
  
          //--------------------------------------
          //  Class description
          //--------------------------------------


  
          public class @ax-student-ar-fl-controls-ColorPicker extends UIComponent implements IFocusManagerComponent {


  
                  public var textField:TextField;


  
                  protected var customColors:Array;


  
                  public static  var defaultColors:Array;


  
                  protected var colorHash:Object;


  
                  protected var paletteBG:DisplayObject;


  
                  protected var selectedSwatch:Sprite;


  
                  protected var _selectedColor:uint;


  
                  protected var rollOverColor:int = -1;


  
                  protected var _editable:Boolean = true;


  
                  protected var _showTextField:Boolean = true;


  
                  protected var isOpen:Boolean = false;


  
                  protected var doOpen:Boolean = false;


  
                  protected var swatchButton:BaseButton;


  
                  protected var colorWell:DisplayObject;


  
                  protected var swatchSelectedSkin:DisplayObject;


  
                  protected var palette:Sprite;


  
                  protected var textFieldBG:DisplayObject;


  
                  protected var swatches:Sprite;


  
                  protected var swatchMap:Array;


  
                  protected var currRowIndex:int;


  
                  protected var currColIndex:int;


  
                  private static  var defaultStyles:Object = {upSkin:"@file_upSkin", disabledSkin:"@file_disabledSkin",
                                                                                                                    overSkin:"@file_overSkin", downSkin:"@file_downSkin", colorWell:"@file_colorWell",
                                                                                                                    swatchSkin:"@file_swatchSkin", swatchSelectedSkin:"@file_swatchSelectedSkin",
                                                                                                                    swatchWidth:10, swatchHeight:10,
                                                                                                                    columnCount:18, swatchPadding:1,
                                                                                                                    textFieldSkin:"@file_textFieldSkin",
                                                                                                                    textFieldWidth:null, textFieldHeight:null, textPadding:3,
                                                                                                                    background:"@file_backgroundSkin", backgroundPadding:5,
                                                                                                                    textFormat:null, focusRectSkin:null, focusRectPadding:null,
                                                                                                                    embedFonts:false
                                                                                                                    };


  
                  public static function getStyleDefinition():Object {
                          return defaultStyles;
                  }


  
                  protected static  const POPUP_BUTTON_STYLES:Object = {
                                                                                                                  disabledSkin:"disabledSkin",
                                                                                                                  downSkin:"downSkin",
                                                                                                                  overSkin:"overSkin",
                                                                                                                  upSkin:"upSkin"
                                                                                                                  };


  
                  protected static  const SWATCH_STYLES:Object = {
                                                                                                                  disabledSkin:"swatchSkin",
                                                                                                                  downSkin:"swatchSkin",
                                                                                                                  overSkin:"swatchSkin",
                                                                                                                  upSkin:"swatchSkin"
                                                                                                                  };


  
                  public function @ax-student-ar-fl-controls-ColorPicker() {
                          super();
                  }
  
                  [Inspectable(type="Color",defaultValue="#000000")]


  
                  public function get selectedColor():uint {
                          if (colorWell == null) {
                                  return 0;
                          }
                          return colorWell.transform.colorTransform.color;
                  }


  
                  public function set selectedColor(value:uint):void {
                          if (!_enabled) {
                                  return;
                          }
                          _selectedColor = value;
                          rollOverColor = -1;
                          currColIndex = currRowIndex = 0;
  
                          // Set the color value immediately to avoid invalidation.
                          var ct:ColorTransform = new ColorTransform();
                          ct.color = value;
                          setColorWellColor(ct);
  
                          invalidate(InvalidationType.DATA);
                  }


  
                  public function get hexValue():String {
                          if (colorWell == null) {
                                  return colorToString(0);
                          }
                          return colorToString(colorWell.transform.colorTransform.color);
                  }
  
                  [Inspectable(defaultValue=true, verbose=1)]


  
                  override public function get enabled():Boolean {
                          return super.enabled;
                  }


  
                  override public function set enabled(value:Boolean):void {
                          super.enabled = value;
                          if (!value) {
                                  close();
                          }
                          swatchButton.enabled = value;
                  }


  
                  public function get editable():Boolean {
                          return _editable;
                  }


  
                  public function set editable(value:Boolean):void {
                          _editable = value;
                          invalidate(InvalidationType.STATE);
                  }
  
                  [Inspectable(defaultValue=true)]


  
                  public function get showTextField():Boolean {
                          return _showTextField;
                  }


  
                  public function set showTextField(value:Boolean):void {
                          invalidate(InvalidationType.STYLES);
                          _showTextField = value;
                  }


  
                  public function get colors():Array {
                          return (customColors != null)?customColors:@ax-student-ar-fl-controls-ColorPicker.defaultColors;
                  }


  
                  public function set colors(value:Array):void {
                          customColors = value;
                          invalidate(InvalidationType.DATA);
                  }


  
                  public function get imeMode():String {
                          return _imeMode;
                  }


  
                  public function set imeMode(value:String):void {
                          _imeMode = value;
                  }


  
                  public function open():void {
                          if (!_enabled) {
                                  return;
                          }
                          doOpen = true;
                          
                          var fm:IFocusManager = focusManager;
                          if (fm) {
                                  fm.defaultButtonEnabled = false;
                          }
                          
                          invalidate(InvalidationType.STATE);
                  }


  
                  public function close():void {
                          if (isOpen) {
                                  stage.removeChild(palette);
                                  isOpen = false;
                                  dispatchEvent(new Event(Event.CLOSE));
                          }
                          
                          var fm:IFocusManager = focusManager;
                          if (fm) {
                                  fm.defaultButtonEnabled = true;
                          }
                          
                          removeStageListener();
                          cleanUpSelected();
                  }


  
                  private function addCloseListener(event:Event) {
                          removeEventListener(Event.ENTER_FRAME, addCloseListener);
                          if (!isOpen) {
                                  return;
                          }
                          addStageListener();
                  }


  
                  protected function onStageClick(event:MouseEvent):void {
                          if (!contains(event.target as DisplayObject) && !palette.contains(event.target as DisplayObject)) {
                                  selectedColor = _selectedColor;
                                  close();
                          }
                  }


  
                  protected function setStyles():void {
                          var bg:DisplayObject = colorWell;
                          
                          var colorWellStyle:Object = getStyleValue("colorWell");
                          if (colorWellStyle != null) {
                                  colorWell = getDisplayObjectInstance(colorWellStyle) as DisplayObject;
                          }
                          addChildAt(colorWell, getChildIndex(swatchButton));
                          copyStylesToChild(swatchButton, POPUP_BUTTON_STYLES);
                          swatchButton.drawNow();
                          
                          if (bg != null && contains(bg) && bg != colorWell) { 
                                  removeChild(bg); 
                          }
                  }


  
                  protected function cleanUpSelected():void {
                          if (swatchSelectedSkin && palette.contains(swatchSelectedSkin)) {
                                  palette.removeChild(swatchSelectedSkin);
                          }
                  }


  
                  protected function onPopupButtonClick(event:MouseEvent):void {
                          if (isOpen) {
                                  close();
                          } else {
                                  open();
                          }
                  }


  
                  override protected function draw():void {        
                          if (isInvalid(InvalidationType.STYLES, InvalidationType.DATA)) {
                                  setStyles();
                                  drawPalette();
                                  setEmbedFonts();
                                  invalidate(InvalidationType.DATA, false);
                                  invalidate(InvalidationType.STYLES, false);
                          }
  
                          if (isInvalid(InvalidationType.DATA)) {
                                  drawSwatchHighlight();
                                  setColorDisplay();
                          }
  
                          if (isInvalid(InvalidationType.STATE)) {
                                  setTextEditable();
                                  if (doOpen) {
                                          doOpen = false;
                                          showPalette();
                                  }
                                  colorWell.visible = enabled;
                          }
                          if (isInvalid(InvalidationType.SIZE, InvalidationType.STYLES)) {
                                  swatchButton.setSize(width, height);
                                  swatchButton.drawNow();
                                  colorWell.width = width;
                                  colorWell.height = height;
                          }
                          super.draw();
                  }


  
                  protected function showPalette():void {
                          if (isOpen) {
                                  positionPalette();
                                  return;
                          }
                          addEventListener(Event.ENTER_FRAME, addCloseListener, false, 0, true);
  
                          stage.addChild(palette);
                          isOpen = true;
                          positionPalette();
  
                          dispatchEvent(new Event(Event.OPEN));
                          stage.focus = textField; // This is causing some issues.
  
                          // Highlight the appropriate swatch.
                          var swatch:Sprite = selectedSwatch;
                          if (swatch == null) {
                                  swatch = findSwatch(_selectedColor);
                          }
                          setSwatchHighlight(swatch);
                  }


  
                  protected function setEmbedFonts():void {
                          var embed:Object = getStyleValue('embedFonts');
                          if (embed != null) {
                                  textField.embedFonts = embed;
                          }
                  }


  
                  protected function drawSwatchHighlight():void {
                          cleanUpSelected();
                          var skin:Object = getStyleValue("swatchSelectedSkin");
                          var swatchPadding:Number = getStyleValue("swatchPadding") as Number;
                          if (skin != null) {
                                  swatchSelectedSkin = getDisplayObjectInstance(skin);
                                  swatchSelectedSkin.x = 0;
                                  swatchSelectedSkin.y = 0;
                                  swatchSelectedSkin.width = (getStyleValue("swatchWidth") as Number) + 2;
                                  swatchSelectedSkin.height = (getStyleValue("swatchHeight") as Number) + 2;
                          }
                  }


  
                  protected function drawPalette():void {
                          if (isOpen) {
                                  stage.removeChild(palette);
                          }
                          palette = new Sprite();
                          drawTextField();
                          drawSwatches();
                          drawBG();
                  }


  
                  protected function drawTextField():void {
                          if (!showTextField) {
                                  return;
                          }
                          var padding:Number = getStyleValue("backgroundPadding") as Number;
                          var textPadding:Number = getStyleValue("textPadding") as Number;
  
                          // Add the TextField background
                          textFieldBG = getDisplayObjectInstance(getStyleValue("textFieldSkin"));
                          if (textFieldBG != null) {
                                  palette.addChild(textFieldBG);
                                  textFieldBG.x = textFieldBG.y = padding;
                          }
  
                          // Format the text field
                          var uiStyles:Object = UIComponent.getStyleDefinition();
                          var defaultTF:TextFormat = enabled ? uiStyles.defaultTextFormat as TextFormat : uiStyles.defaultDisabledTextFormat as TextFormat;
                          textField.setTextFormat(defaultTF);
  
                          var tf:TextFormat = getStyleValue("textFormat") as TextFormat;
                          if (tf != null) {
                                  textField.setTextFormat(tf);
                          } else {
                                  tf = defaultTF;
                          }
                          textField.defaultTextFormat = tf;
                          setEmbedFonts();
  
                          textField.restrict = "A-Fa-f0-9#";
                          textField.maxChars = 6;
                          palette.addChild(textField);
  
                          textField.text = " #888888 ";
                          textField.height = textField.textHeight + 3;
                          textField.width = textField.textWidth + 3;
                          textField.text = "";
                          textField.x = textField.y = padding + textPadding;
  
                          textFieldBG.width = textField.width + (textPadding*2);
                          textFieldBG.height = textField.height + (textPadding*2);
                          setTextEditable();
                  }


  
                  protected function drawSwatches():void {
                          var padding:Number = getStyleValue("backgroundPadding") as Number;
                          var swatchY:Number = (showTextField ? textFieldBG.y + textFieldBG.height + padding : padding);
  
                          swatches = new Sprite();
                          palette.addChild(swatches);
                          swatches.x = padding;
                          swatches.y = swatchY;
  
                          var cols:uint = getStyleValue("columnCount") as uint;
                          var pad:uint = getStyleValue("swatchPadding") as uint;
                          var w:Number = getStyleValue("swatchWidth") as Number;
                          var h:Number = getStyleValue("swatchHeight") as Number;
  
                          colorHash = {};
                          swatchMap = [];
  
                          var l:uint = Math.min(1024, colors.length);
                          var rc:int = -1;
                          for (var  i:uint=0; i<l; i++) {
                                  var s:Sprite = createSwatch(colors[i]);
  
                                  s.x = (w + pad) * (i\%cols);
                                  if (s.x == 0) {
                                          swatchMap.push([s]);
                                          rc++;
                                  } else {
                                          swatchMap[rc].push(s);
                                  }
                                  colorHash[colors[i]] = {swatch:s, row:rc, col:swatchMap[rc].length-1};
                                  s.y = Math.floor(i/cols) * (h + pad);
                                  swatches.addChild(s);
                          }
                  }


  
                  protected function drawBG():void {
                          var bg:Object = getStyleValue("background");
                          if (bg != null) {
                                  paletteBG = getDisplayObjectInstance(bg) as Sprite;
                          }
                          if (paletteBG == null) {
                                  return;
                          }
                          var padding:Number = Number(getStyleValue("backgroundPadding"));
                          paletteBG.width = Math.max(showTextField?textFieldBG.width:0, swatches.width) + padding*2;
                          paletteBG.height = swatches.y + swatches.height + padding;
                          palette.addChildAt(paletteBG, 0);
                  }


  
                  protected function positionPalette():void {
                          var p:Point = swatchButton.localToGlobal(new Point(0,0));
                          var padding:Number = getStyleValue("backgroundPadding") as Number;
  
                          if (p.x + palette.width > stage.stageWidth) {// Doesn't fit
                                  palette.x = (p.x - palette.width) <<0;
                          } else {
                                  palette.x = (p.x + swatchButton.width + padding) <<0;
                          }
                          palette.y = Math.max(0, Math.min(p.y, stage.stageHeight-palette.height)) <<0;
                  }


  
                  protected function setTextEditable():void {
                          if (!showTextField) {
                                  return;
                          }
                          textField.type = editable?TextFieldType.INPUT:TextFieldType.DYNAMIC;
                          textField.selectable = editable;
                  }


  
                  override protected function keyUpHandler(event:KeyboardEvent):void {
                          if (!isOpen) { return; }
                          
                          var newColor:uint;
                          var cTransform:ColorTransform = new ColorTransform();
  
                          if (editable && showTextField) {
                                  // Get the color that is currently entered.
                                  var color:String = textField.text;
                                  
                                  // Works with or without the #
                                  if (color.indexOf("#") > -1) {
                                          color = color.replace(/^\s+|\s+ $/g, "");
                                          color = color.replace(/#/g, "");
                                  }$ // Convert to a color.
                                  newColor = parseInt(color, 16);
                                  
                                  // Try and select the swatch
                                  var swatch:Sprite = findSwatch(newColor);
                                  setSwatchHighlight(swatch);
                                  
                                  // Colorize the ColorWell
                                  cTransform.color = newColor;
                                  setColorWellColor(cTransform);
                          } else {
                                  newColor = rollOverColor;
                                  cTransform.color = newColor;
                          }
                          // If the ENTER key, select the color
                          if (event.keyCode != Keyboard.ENTER) {
                                  return;
                          }
  
                          // Verify the color, and close the palette.
                          dispatchEvent(new @fileEvent(@fileEvent.ENTER, newColor));
                          
                          _selectedColor = rollOverColor;
                          setColorText(cTransform.color);
                          rollOverColor = cTransform.color;        
                          
                          dispatchEvent(new @fileEvent(@fileEvent.CHANGE, selectedColor));
                          close();
                  }


  
                  protected function positionTextField():void {
                          if (!showTextField) {
                                  return;
                          }
                          var padding:Number = getStyleValue("backgroundPadding") as Number;
                          var textPadding:Number = getStyleValue("textPadding") as Number;
  
                          textFieldBG.x = paletteBG.x + padding;
                          textFieldBG.y = paletteBG.y + padding;
                          textField.x = textFieldBG.x + textPadding;
                          textField.y = textFieldBG.y + textPadding;
                  }


  
                  protected function setColorDisplay():void {
                          if (!swatchMap.length) {
                                  return;
                          }
                          var ct:ColorTransform = new ColorTransform(0,0,0,1,_selectedColor>>16,_selectedColor>>8&0xFF,_selectedColor&0xFF,0);
                          setColorWellColor(ct);
                          setColorText(_selectedColor);
                          var swatch:Sprite = findSwatch(_selectedColor);
                          setSwatchHighlight(swatch);
  
                          if (swatchMap.length && colorHash[_selectedColor] == undefined) {
                                  cleanUpSelected();
                          }
                  }


  
                  protected function setSwatchHighlight(swatch:Sprite):void {
                          if (swatch == null) {
                                  if (palette.contains(swatchSelectedSkin)) {
                                          palette.removeChild(swatchSelectedSkin);
                                  }
                                  return;
                          } else if (!palette.contains(swatchSelectedSkin) && colors.length > 0) {
                                  palette.addChild(swatchSelectedSkin);
                          } else if (!colors.length) {
                                  return;
                          }
  
                          var swatchPadding:Number = getStyleValue("swatchPadding") as Number;
                          palette.setChildIndex(swatchSelectedSkin, palette.numChildren-1);
                          swatchSelectedSkin.x = swatches.x + swatch.x - 1;
                          swatchSelectedSkin.y = swatches.y + swatch.y - 1;
  
                          var color = swatch.getChildByName('color').transform.colorTransform.color;
                          currColIndex = colorHash[color].col;
                          currRowIndex = colorHash[color].row;
                  }


  
                  protected function findSwatch(color:uint):Sprite {
                          if (!swatchMap.length) {
                                  return null;
                          }
                          var so:Object = colorHash[color];
                          if (so != null) {
                                  return so.swatch;
                          }
                          return null;
                  }


  
                  protected function onSwatchClick(event:MouseEvent):void {
                          var cTransform:ColorTransform = event.target.getChildByName('color').transform.colorTransform;
                          _selectedColor = cTransform.color;
                          dispatchEvent(new @fileEvent(@fileEvent.CHANGE, selectedColor));
                          close();
                  }


  
                  protected function onSwatchOver(event:MouseEvent):void {
                          var color:BaseButton = event.target.getChildByName("color") as BaseButton;
                          var cTransform:ColorTransform = color.transform.colorTransform;
                          setColorWellColor(cTransform);
                          setSwatchHighlight(event.target as Sprite);
                          setColorText(cTransform.color);
                          dispatchEvent(new @fileEvent(@fileEvent.ITEM_ROLL_OVER, cTransform.color));
                  }


  
                  protected function onSwatchOut(event:MouseEvent):void {
                          var cTransform:ColorTransform = event.target.transform.colorTransform;
                          dispatchEvent(new @fileEvent(@fileEvent.ITEM_ROLL_OUT, cTransform.color));
                  }


  
                  protected function setColorText(color:uint):void {
                          if (textField == null) {
                                  return;
                          }
                          textField.text = "#"+colorToString(color);
                  }


  
                  protected function colorToString(color:uint):String {
                          var colorText:String = color.toString(16);
                          while (colorText.length < 6) {
                                  colorText = "0" + colorText;
                          }
                          return colorText;
                  }


  
                  protected function setColorWellColor(colorTransform:ColorTransform):void {
                          if (!colorWell) {
                                  return;
                          }
                          colorWell.transform.colorTransform = colorTransform;
                  }


  
                  protected function createSwatch(color:uint):Sprite {
                          var swatch:Sprite = new Sprite();
  
                          // Draw the Color part of the swatch
                          var swatchSkin:BaseButton = new BaseButton();
                          swatchSkin.focusEnabled = false;
                          var w:Number = getStyleValue("swatchWidth") as Number;
                          var h:Number = getStyleValue("swatchHeight") as Number;
                          swatchSkin.setSize(w, h);
                          swatchSkin.transform.colorTransform = new ColorTransform(0,0,0,1,color>>16,color>>8&0xFF,color&0xFF,0);
                          copyStylesToChild(swatchSkin, SWATCH_STYLES);
                          swatchSkin.mouseEnabled = false;
                          swatchSkin.drawNow();
                          swatchSkin.name = "color";
                          swatch.addChild(swatchSkin);
  
                          // Draw the border/background
                          var padding:Number = getStyleValue("swatchPadding") as Number;
                          var g:Graphics = swatch.graphics;
                          g.beginFill(0x000000);
                          g.drawRect(-padding, -padding, w+padding*2, h+padding*2);
                          g.endFill();
  
                          swatch.addEventListener(MouseEvent.CLICK, onSwatchClick, false, 0, true);
                          swatch.addEventListener(MouseEvent.MOUSE_OVER, onSwatchOver, false, 0, true);
                          swatch.addEventListener(MouseEvent.MOUSE_OUT, onSwatchOut, false, 0, true);
                          return swatch;
                  }


  
                  protected function addStageListener(event:Event = null):void {
                          stage.addEventListener(MouseEvent.MOUSE_DOWN, onStageClick, false, 0, true);
                  }


  
                  protected function removeStageListener(event:Event = null):void {
                          stage.removeEventListener(MouseEvent.MOUSE_DOWN, onStageClick, false);
                  }


  
                  override protected function focusInHandler(event:FocusEvent):void {
                          super.focusInHandler(event);
                          setIMEMode(true);
                  }


  
                  override protected function focusOutHandler(event:FocusEvent):void {
                          if (event.relatedObject == textField) { 
                                  setFocus();
                                  return;        } // New focus is our textfield.
                          
                          if (isOpen) { close(); }
                          super.focusOutHandler(event);
                          setIMEMode(false);
                  }


  
                  override protected function isOurFocus(target:DisplayObject):Boolean {
                          return target == textField || super.isOurFocus(target);
                  }


  
                  override protected function keyDownHandler(event:KeyboardEvent):void {
                          switch (event.keyCode) {
                                  case Keyboard.SHIFT :
                                  case Keyboard.CONTROL :
                                          return;
                          }
                          if (event.ctrlKey) {
                                  switch (event.keyCode) {
                                          case Keyboard.DOWN :
                                                  open();
                                                  break;
                                          case Keyboard.UP :
                                                  close();
                                                  break;
                                  }
                                  return;
                          }
                          // Palette is closed. Just open it.
                          if (!isOpen) {
                                  switch(event.keyCode) {
                                          case Keyboard.UP:
                                          case Keyboard.DOWN:
                                          case Keyboard.LEFT:
                                          case Keyboard.RIGHT:
                                          case Keyboard.SPACE:
                                                  open();
                                                  return;
                                  }
                          }
                          // Change the number of allowed chatacters depending on input
                          textField.maxChars = (event.keyCode == "#".charCodeAt(0) || textField.text.indexOf("#") > -1) ? 7 : 6;
                          // Palette is open. Do appropriate action.
                          switch (event.keyCode) {
                                  case Keyboard.TAB :
                                          var swatch:Sprite = findSwatch(_selectedColor);
                                          setSwatchHighlight(swatch);
                                          return;
                                          break;
                                  case Keyboard.HOME :
                                          currColIndex = currRowIndex = 0;// Set to first color
                                          break;
                                  case Keyboard.END :
                                          currColIndex = swatchMap[swatchMap.length-1].length-1;
                                          currRowIndex = swatchMap.length-1;// Set to last color
                                          break;
                                  case Keyboard.PAGE_DOWN :
                                          currRowIndex = swatchMap.length-1;// set to bottom of the column.
                                          break;
                                  case Keyboard.PAGE_UP :
                                          currRowIndex = 0;// Set to top of the column.
                                          break;
                                  case Keyboard.ESCAPE :
                                          if (isOpen) {
                                                  selectedColor = _selectedColor;
                                          }
                                          close();
                                          return;
                                          break;
                                  case Keyboard.ENTER :
                                          // This is handled in the TextKeyUp method...
                                          return;
                                  case Keyboard.UP :
                                          currRowIndex = Math.max(-1, currRowIndex-1);
                                          if (currRowIndex == -1) {
                                                  currRowIndex = swatchMap.length-1;
                                          }
                                          break;
                                  case Keyboard.DOWN :
                                          currRowIndex = Math.min(swatchMap.length, currRowIndex+1);
                                          if (currRowIndex == swatchMap.length) {
                                                  currRowIndex = 0;
                                          }
                                          break;
                                  case Keyboard.RIGHT :
                                          currColIndex = Math.min(swatchMap[currRowIndex].length, currColIndex+1);
                                          if (currColIndex == swatchMap[currRowIndex].length) {
                                                  currColIndex = 0;
                                                  currRowIndex = Math.min(swatchMap.length, currRowIndex+1);
                                                  if (currRowIndex == swatchMap.length) {
                                                          currRowIndex = 0;
                                                  }
                                          }
                                          break;
                                  case Keyboard.LEFT :
                                          currColIndex = Math.max(-1, currColIndex-1);
                                          if (currColIndex == -1) {
                                                  currColIndex = swatchMap[currRowIndex].length-1;
                                                  currRowIndex = Math.max(-1, currRowIndex-1);
                                                  if (currRowIndex == -1) {
                                                          currRowIndex = swatchMap.length-1;
                                                  }
                                          }
                                          break;
                                  default :
                                          return;// Do Nothing.
                          }
                          
                          var cTransform:ColorTransform = swatchMap[currRowIndex][currColIndex].getChildByName("color").transform.colorTransform;
                          rollOverColor = cTransform.color;
                          setColorWellColor(cTransform);
  
                          setSwatchHighlight(swatchMap[currRowIndex][currColIndex]);
                          setColorText(cTransform.color);
  
                  }


  
                  override protected function configUI():void {
                          super.configUI();
                          
                          tabChildren = false;
  
                          // Only create the @ax-student-ar-fl-controls-ColorPicker default colors once in an swf.
                          if (@ax-student-ar-fl-controls-ColorPicker.defaultColors == null) {
                                  @ax-student-ar-fl-controls-ColorPicker.defaultColors = [];
                                  for (var i:uint=0; i<216; i++) {
                                          @ax-student-ar-fl-controls-ColorPicker.defaultColors.push( ((i/6%3<<0)+((i/108)<<0)*3)*0x33<<16 | i%6*0x33<<8  | (i/18<<0)%6*0x33 );
                                  }
                          }
                          colorHash = {};
                          swatchMap = [];
  
                          textField = new TextField();
                          textField.tabEnabled = false;
                          //textField.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler,false,0,true);
                           //textField.addEventListener(KeyboardEvent.KEY_UP, onTextKeyUp, false,0,true);
  
                          swatchButton = new BaseButton();
                          swatchButton.focusEnabled = false;
                          swatchButton.useHandCursor = false;
                          swatchButton.autoRepeat = false;
                          swatchButton.setSize(25, 25);
                          swatchButton.addEventListener(MouseEvent.CLICK, onPopupButtonClick, false, 0, true);
                          addChild(swatchButton);
  
                          palette = new Sprite();
                          palette.tabChildren = false;
                          palette.cacheAsBitmap = true;
                  }
                  
          }
  }

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.