Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Mar 7th, 2012  |  syntax: None  |  size: 15.64 KB  |  views: 88  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. package com.dVyper.utils {
  2.         //
  3.         import flash.display.Bitmap;
  4.         import flash.display.BitmapData;
  5.         import flash.display.GradientType;
  6.         import flash.display.SimpleButton;
  7.         import flash.display.Sprite;
  8.         import flash.display.Stage;
  9.         import flash.events.MouseEvent;
  10.         import flash.filters.BitmapFilter;
  11.         import flash.filters.BitmapFilterQuality;
  12.         import flash.filters.BlurFilter;
  13.         import flash.filters.DropShadowFilter;
  14.         import flash.filters.GlowFilter;
  15.         import flash.geom.Matrix;
  16.         import flash.geom.Point;
  17.         import flash.geom.Rectangle;
  18.         import flash.text.TextField;
  19.         import flash.text.TextFieldAutoSize;
  20.         import flash.text.TextFormat;
  21.         import flash.text.TextFormatAlign;
  22.         //
  23.         public class Alert {
  24.                 //
  25.                 private static var stage:Stage = null;
  26.                 private static var btnWidth:int = 75
  27.                 private static var btnHeight:int = 18;
  28.                 private static var minimumWidths:Array = new Array(150, 230, 310);
  29.                 //
  30.                 /*      ALERT DIALOG OPTIONS
  31.                
  32.                 background:String               -       Type of background
  33.                                                                         >       "none" - invisible background
  34.                                                                         >       "nonenotmodal" -  no background and make the area behind the Alert prompt focussable
  35.                                                                         >       "simple -  simple colour background
  36.                                                                         >       "blur" -  blurred background
  37.                                                                         "simple" style is used if background is not specified
  38.                
  39.                 buttons:Array                   -       An array (maximum of 3) containing the Strings of the buttons to be shown in the Alert prompt
  40.                 callBack:Function               -       The function to be called when a button on the Alert prompt has been clicked - returns the name of the button that was clicked
  41.                 colour:int                              -       Main colour for the Alert
  42.                 promptAlpha:int                 -       Alpha of the Alert prompt
  43.                 textColour:int                  -       Colour of the text shown in the Alert dialog
  44.                 position:Point                  -       Position of the Alert prompt
  45.        
  46.                 */
  47.                 public static function init(stageReference:Stage):void {
  48.                         stage = stageReference;
  49.                 }
  50.                 public static function show(Text:* = "Made by dVyper", ALERTOPTIONS:Object = null):void {
  51.                         if (stage == null) {
  52.                                 trace("Alert class has not been initialised!");
  53.                                 return;
  54.                         }
  55.                         var alertOptions:AlertOptions = new AlertOptions(ALERTOPTIONS, Text);
  56.                         var myAlert:Sprite = new Sprite();
  57.                         myAlert.addChild(createBackground(alertOptions));
  58.                         myAlert.addChild(getPrompt(alertOptions));
  59.                         assignListeners(myAlert, alertOptions);
  60.                         stage.addChild(myAlert);
  61.                 }
  62.                 //
  63.                 private static function assignListeners(myAlert:Sprite, alertOptions:AlertOptions):void {
  64.                         var promptBackground:* = myAlert.getChildAt(1);
  65.                         var allButtons:Array = new Array();
  66.                         for (var n:int;n<alertOptions.buttons.length;n++) {
  67.                                 var button:SimpleButton = promptBackground.getChildByName(alertOptions.buttons[n])
  68.                                 button.addEventListener(MouseEvent.CLICK, myFunction);
  69.                                 allButtons.push(button);
  70.                         }
  71.                         //      THIS IS DECLARED HERE SIMPLY SO I HAVE ACCESS TO alertOptions
  72.                         function myFunction(event:MouseEvent):void {
  73.                                 for (var i:int;i<allButtons.length;i++) {
  74.                                         allButtons[i].removeEventListener(MouseEvent.CLICK, myFunction);
  75.                                 }
  76.                                 closeAlert(myAlert);
  77.                                 if (alertOptions.callback != null) alertOptions.callback(event.target.name);
  78.                         }
  79.                 }
  80.                 //
  81.                 private static function closeAlert(myAlert:Sprite):void {
  82.                         var promptBackground:* = myAlert.getChildAt(1);
  83.                         promptBackground.removeEventListener(MouseEvent.MOUSE_DOWN, doStartDrag);
  84.                         promptBackground.removeEventListener(MouseEvent.MOUSE_UP, doStopDrag);
  85.                         stage.removeChild(myAlert);
  86.                         myAlert = null;
  87.                 }
  88.                 //      Creates the background for the Alert
  89.                 private static function createBackground(alertOptions:AlertOptions):Sprite {
  90.                         var myBackground:Sprite = new Sprite();
  91.                         var colour:int = alertOptions.colour;
  92.                         switch (alertOptions.background) {
  93.                                 case "blur" :
  94.                                         var BackgroundBD:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, true, 0xFF000000+colour);
  95.                                         var stageBackground:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight);
  96.                                         stageBackground.draw(stage);
  97.                                         var rect:Rectangle = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight);
  98.                                         var point:Point = new Point(0, 0);
  99.                                         var multiplier:uint = 120;
  100.                                         BackgroundBD.merge(stageBackground, rect, point, multiplier, multiplier, multiplier, multiplier);
  101.                                         BackgroundBD.applyFilter(BackgroundBD, rect, point, new BlurFilter(5, 5));
  102.                                         var bitmap:Bitmap = new Bitmap(BackgroundBD);
  103.                                         myBackground.addChild(bitmap);
  104.                                         break;
  105.                                 case "none" :
  106.                                         myBackground.graphics.beginFill(colour, 0);     //      BACKGROUND IS STILL THERE BUT IS INVISIBLE
  107.                                         myBackground.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
  108.                                         myBackground.graphics.endFill();
  109.                                         break;
  110.                                 case "nonenotmodal" :
  111.                                         //      DRAW NO BACKGROUND AT ALL
  112.                                         break;
  113.                                 case "simple" :
  114.                                         myBackground.graphics.beginFill(colour, 0.3);
  115.                                         myBackground.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
  116.                                         myBackground.graphics.endFill();
  117.                                         break;
  118.                         }
  119.                         return myBackground;
  120.                 }
  121.                 //      Returns an 'OK' button
  122.                 private static function createButton(buttonText:String, alertOptions:AlertOptions):SimpleButton {
  123.                         var colors:Array = new Array();
  124.                         var alphas:Array = new Array(1, 1);
  125.                         var ratios:Array = new Array(0, 255);
  126.                         var gradientMatrix:Matrix = new Matrix();
  127.                         gradientMatrix.createGradientBox(btnWidth, btnHeight, Math.PI/2, 0, 0);
  128.                         //
  129.                         var ellipseSize:int = 2;
  130.                         var btnUpState:Sprite = new Sprite();
  131.                         colors = [0xFFFFFF, alertOptions.colour];
  132.                         /* added stroke hinting */btnUpState.graphics.lineStyle(3, brightenColour(alertOptions.colour, -50), 1, true, "none");
  133.                         btnUpState.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, gradientMatrix);
  134.                         btnUpState.graphics.drawRoundRect(0, 0, btnWidth, btnHeight, ellipseSize, ellipseSize);
  135.                         btnUpState.addChild(createButtonTextField(buttonText, alertOptions));
  136.                         //
  137.                         var btnOverState:Sprite = new Sprite();
  138.                         colors = [0xFFFFFF, brightenColour(alertOptions.colour, 50)];
  139.                         /* added stroke hinting */btnOverState.graphics.lineStyle(1, brightenColour(alertOptions.colour, -50), 1, true, "none");
  140.                         btnOverState.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, gradientMatrix);
  141.                         btnOverState.graphics.drawRoundRect(0, 0, btnWidth, btnHeight, ellipseSize, ellipseSize);
  142.                         btnOverState.addChild(createButtonTextField(buttonText, alertOptions))
  143.                         //
  144.                         var btnDownState:Sprite = new Sprite();
  145.                         colors = [brightenColour(alertOptions.colour, -15), brightenColour(alertOptions.colour, 50)];
  146.                         /* added stroke hinting */btnDownState.graphics.lineStyle(1, brightenColour(alertOptions.colour, -50), 1, true, "none");
  147.                         btnDownState.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, gradientMatrix);
  148.                         btnDownState.graphics.drawRoundRect(0, 0, btnWidth, btnHeight, ellipseSize, ellipseSize);
  149.                         btnDownState.addChild(createButtonTextField(buttonText, alertOptions))
  150.                         //
  151.                         var myButton:SimpleButton = new SimpleButton(btnUpState, btnOverState, btnDownState, btnOverState);
  152.                         myButton.name = buttonText;
  153.                         return myButton;
  154.                 }
  155.                 //      returns a Sprite containing a prompt positioned in the middle of the stage
  156.                 private static function getPrompt(alertOptions:AlertOptions):Sprite {
  157.                         var actualPrompt:Sprite = createPrompt(alertOptions);
  158.                         actualPrompt.name = "actual_prompt";
  159.                         actualPrompt.addEventListener(MouseEvent.MOUSE_DOWN, doStartDrag);
  160.                         actualPrompt.addEventListener(MouseEvent.MOUSE_UP, doStopDrag);
  161.                         if (alertOptions.position) {
  162.                                 actualPrompt.x = alertOptions.position.x;
  163.                                 actualPrompt.y = alertOptions.position.y;
  164.                         } else {
  165.                                 actualPrompt.x = (stage.stageWidth/2)-(actualPrompt.width/2);
  166.                                 actualPrompt.y = (stage.stageHeight/2)-(actualPrompt.height/2);
  167.                         }
  168.                         return actualPrompt;
  169.                 }
  170.                 //
  171.                 private static function getBlurFilter():BitmapFilter {
  172.             var blurX:Number = 100;
  173.             var blurY:Number = 100;
  174.             return new BlurFilter(blurX, blurY, BitmapFilterQuality.HIGH);
  175.         }
  176.                 //
  177.                 private static function getDropShadowFilter(Colour:int):DropShadowFilter {
  178.                         var color:Number = 0x000000;
  179.             var angle:Number = 90;
  180.             var alpha:Number = 0.6;
  181.             var blurX:Number = 12;
  182.             var blurY:Number = 4;
  183.             var distance:Number = 1;
  184.             var strength:Number = 1;
  185.             var inner:Boolean = false;
  186.             var knockout:Boolean = false;
  187.             var quality:Number = BitmapFilterQuality.LOW;
  188.             return new DropShadowFilter(distance, angle, color, alpha, blurX, blurY, strength, quality, inner, knockout);
  189.                 }      
  190.                 //
  191.                 private static function getGlowFilter(Colour:int):GlowFilter {
  192.                         var color:Number = 0xFFFFFF;
  193.             var alpha:Number = 0.8;
  194.             var blurX:Number = 15;
  195.             var blurY:Number = 15;
  196.             var strength:Number = 0.7;
  197.             var inner:Boolean = true;
  198.             var knockout:Boolean = false;
  199.             var quality:Number = BitmapFilterQuality.HIGH;
  200.             return new GlowFilter(color, alpha, blurX, blurY, strength, quality, inner, knockout);
  201.                 }
  202.                 //      returns a sprite containing a prompt complete with a background, the specified text and an OK button
  203.                 private static function createPrompt(alertOptions:AlertOptions):Sprite {
  204.                         var promptBackground:Sprite = new Sprite();
  205.                         var textField:TextField = createTextField(alertOptions);
  206.                         var myWidth:int = textField.width+30;
  207.                         var myHeight:int = textField.height+65;
  208.                         if (myWidth < minimumWidths[alertOptions.buttons.length-1]) {
  209.                                 myWidth = minimumWidths[alertOptions.buttons.length-1];
  210.                         }
  211.                         if (myHeight < 100) {
  212.                                 myHeight = 100;
  213.                         }
  214.                         if (myHeight > stage.stageHeight) {
  215.                                 myHeight = stage.stageHeight - 20;
  216.                                 textField.autoSize = TextFieldAutoSize.NONE;
  217.                                 textField.height = stage.stageHeight-40;
  218.                         }
  219.                         //      Create a background for the prompt
  220.                         var ellipseSize:int = 10;
  221.                         /* added stroke hinting with borderColour option */promptBackground.graphics.lineStyle(1, alertOptions.borderColour, 1, true, "none");
  222.                         promptBackground.graphics.beginFill(alertOptions.colour);
  223.                         promptBackground.graphics.drawRoundRect(0, 0, myWidth, myHeight, ellipseSize, ellipseSize);
  224.                         promptBackground.graphics.endFill();
  225.                         //      Add the specified text to the prompt
  226.                         /* rounded pixel values to promote better strokes */textField.x = int( (promptBackground.width/2)-(textField.width/2) );
  227.                         /* rounded pixel values to promote better strokes */textField.y = int( (promptBackground.height/2)-(textField.height/2)-10 );
  228.                         //      ADD SPECIFIED BUTTONS TO THE PROMPT
  229.                         var alertButtons:Array = new Array();
  230.                         for (var n:int;n<alertOptions.buttons.length;n++) {
  231.                                 alertButtons.push(createButton(alertOptions.buttons[n], alertOptions));
  232.                         }
  233.                         promptBackground.filters = [getGlowFilter(alertOptions.colour), getDropShadowFilter(alertOptions.colour)];
  234.                         promptBackground.alpha = alertOptions.promptAlpha;
  235.                         var actualPrompt:Sprite = new Sprite();
  236.                         actualPrompt.addChild(promptBackground);
  237.                         switch (alertButtons.length) {
  238.                                 case 1 :
  239.                                         alertButtons[0].x = (actualPrompt.width/2)-(btnWidth/2);
  240.                                         break;
  241.                                 case 2 :
  242.                                         alertButtons[0].x = (actualPrompt.width/2)-btnWidth-10;
  243.                                         alertButtons[1].x = alertButtons[0].x+btnWidth+15;
  244.                                         break;
  245.                                 case 3 :
  246.                                         alertButtons[1].x = (actualPrompt.width/2)-(btnWidth/2)
  247.                                         alertButtons[0].x = alertButtons[1].x-btnWidth-15;
  248.                                         alertButtons[2].x = alertButtons[1].x+btnWidth+15;
  249.                                         break;
  250.                         }
  251.                         actualPrompt.addChild(textField);
  252.                         for (var i:int;i<alertButtons.length;i++) {
  253.                                 alertButtons[i].y = actualPrompt.height-35;
  254.                                 actualPrompt.addChild(alertButtons[i]);
  255.                         }
  256.                         //
  257.                         return actualPrompt;
  258.                 }
  259.                 //
  260.                 private static function createButtonTextField(Text:String, alertOptions:AlertOptions):TextField {
  261.                         var myTextField:TextField = new TextField();
  262.                         myTextField.textColor = alertOptions.textColour;
  263.                         myTextField.selectable = false;
  264.                         myTextField.width = btnWidth;
  265.                         myTextField.height = btnHeight;
  266.                         var myTextFormat:TextFormat = new TextFormat();
  267.                         myTextFormat.align = TextFormatAlign.CENTER;
  268.                         myTextField.defaultTextFormat = myTextFormat;
  269.                         Text = "<b>"+Text+"</b>";
  270.                         myTextField.htmlText = '<font face="Verdana">'+Text+'</font>';
  271.                         myTextField.x = (btnWidth/2)-(myTextField.width/2);
  272.                         return myTextField;
  273.                 }
  274.                 private static function createTextField(alertOptions:AlertOptions):TextField {
  275.                         var Text:String = alertOptions.text;
  276.                         var myTextField:TextField = new TextField();
  277.                         myTextField.textColor = alertOptions.textColour;
  278.                         myTextField.multiline = true;
  279.                         myTextField.selectable = false;
  280.                         myTextField.autoSize = TextFieldAutoSize.CENTER;       
  281.                         myTextField.htmlText = '<font face="Verdana">'+Text+'</font>';
  282.                         myTextField.x = (btnWidth/2)-(myTextField.width/2);
  283.                         return myTextField;
  284.                 }
  285.                 //
  286.                 //      Helper functions
  287.                 //-----------------------------------------------------------------
  288.                 //
  289.                 //      returns a brighter version of the specified colour
  290.                 private static function brightenColour(colour:int, modifier:int):int {
  291.                         var hex:Array = hexToRGB(colour);
  292.                         var red:int = keepInBounds(hex[0]+modifier);
  293.                         var green:int = keepInBounds(hex[1]+modifier);
  294.                         var blue:int = keepInBounds(hex[2]+modifier);
  295.                         return RGBToHex(red, green, blue);
  296.                 }
  297.                 private static function doStartDrag(event:MouseEvent):void {
  298.                         if (event.target is Sprite) event.currentTarget.startDrag();
  299.                 }
  300.                 private static function doStopDrag(event:MouseEvent):void {
  301.                         if (event.target is Sprite) event.currentTarget.stopDrag();
  302.                 }
  303.                 private static function hexToRGB (hex:uint):Array {
  304.                         var Colours:Array = new Array();
  305.                         Colours.push(hex >> 16);
  306.                         var temp:uint = hex ^ Colours[0] << 16;
  307.                         Colours.push(temp >> 8);
  308.                         Colours.push(temp ^ Colours[1] << 8);
  309.                         return Colours;
  310.                 }
  311.                 private static function keepInBounds(number:int):int {
  312.                         if (number < 0) number = 0;
  313.                         if (number > 255) number = 255;
  314.                         return number;
  315.                 }              
  316.                 private static function RGBToHex(uR:int, uG:int, uB:int):int {
  317.                         var uColor:uint;
  318.                         uColor =  (uR & 255) << 16;
  319.                         uColor += (uG & 255) << 8;
  320.                         uColor += (uB & 255);
  321.                         return uColor;
  322.                 }
  323.         }
  324. }
  325. import flash.geom.Point;
  326. internal class AlertOptions {
  327.         //
  328.         public var background:String;
  329.         public var buttons:Array = new Array();
  330.         public var callback:Function;
  331.         public var colour:int;
  332.         /* added this option */public var borderColour:int;
  333.         public var fadeIn:Boolean;
  334.         public var position:Point;
  335.         public var promptAlpha:Number;
  336.         public var text:String;
  337.         public var textColour:int = 0x000000;
  338.         //
  339.         public function AlertOptions(alertOptions:Object, Text:*):void {
  340.                 if (alertOptions != null) {
  341.                         if (alertOptions.background == null) {
  342.                                 background = "simple"; 
  343.                         } else {
  344.                                 background = alertOptions.background;
  345.                         }
  346.                         if (alertOptions.buttons == null) {
  347.                                 buttons = ["OK"];
  348.                         } else {
  349.                                 if (alertOptions.buttons.length > 3) {
  350.                                         buttons = alertOptions.buttons.slice(0, 2);
  351.                                 } else {
  352.                                         buttons = alertOptions.buttons;
  353.                                 }
  354.                         }
  355.                         callback = alertOptions.callback;
  356.                         if (alertOptions.colour == null) {
  357.                                 colour = 0x4E7DB1;
  358.                         } else {
  359.                                 colour = alertOptions.colour;
  360.                         }
  361.                         /* Added this code here */
  362.                         if (alertOptions.borderColour == null) {
  363.                                 borderColour = 0;
  364.                         } else {
  365.                                 borderColour = alertOptions.borderColour;
  366.                         }
  367.                         /* end my code add */
  368.                         position = alertOptions.position;
  369.                         if (alertOptions.promptAlpha == null) {
  370.                                 promptAlpha = 0.9;
  371.                         } else {
  372.                                 promptAlpha = alertOptions.promptAlpha;
  373.                         }
  374.                         if (alertOptions.textColour != null) {
  375.                                 textColour = alertOptions.textColour;
  376.                         } else {
  377.                                 textColour = 0x000000;
  378.                         }
  379.                 } else {
  380.                         background = "simple";
  381.                         buttons = ["OK"];
  382.                         colour = 0x4E7DB1;
  383.                         borderColour = 0;
  384.                         promptAlpha = 0.9;
  385.                         textColour = 0x000000;
  386.                 }
  387.                 text = Text.toString();
  388.         }
  389. }
clone this paste RAW Paste Data