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

externalinterface

By: a guest on Dec 24th, 2012  |  syntax: ActionScript  |  size: 13.64 KB  |  views: 44  |  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. //class ExternalInterface
  2. package flash.external
  3. {
  4.     import flash.system.*;
  5.     import flash.utils.*;
  6.    
  7.     public final class ExternalInterface extends Object
  8.     {
  9.         public function ExternalInterface()
  10.         {
  11.             super();
  12.             return;
  13.         }
  14.  
  15.         public static function get available():Boolean
  16.         {
  17.         }
  18.  
  19.         public static function addCallback(arg1:String, arg2:Function):void
  20.         {
  21.             var functionName:String;
  22.             var closure:Function;
  23.             var hasNullCallback:Boolean;
  24.             var wrapperClosure:Function;
  25.  
  26.             var loc1:*;
  27.             hasNullCallback = false;
  28.             wrapperClosure = null;
  29.             functionName = arg1;
  30.             closure = arg2;
  31.             if (available)
  32.             {
  33.                 _initJS();
  34.                 hasNullCallback = closure == null;
  35.                 wrapperClosure = function (arg1:String, arg2:Array):String
  36.                 {
  37.                     return _callIn(closure, arg1, arg2);
  38.                 }
  39.                 _addCallback(functionName, wrapperClosure, hasNullCallback);
  40.                 if (activeX == true && !(objectID == null))
  41.                 {
  42.                     _evalJS("__flash__addCallback(document.getElementById(\"" + objectID + "\"), \"" + functionName + "\");");
  43.                 }
  44.             }
  45.             else
  46.             {
  47.                 Error.throwError(Error, 2067);
  48.             }
  49.             return;
  50.         }
  51.  
  52.         public static function call(arg1:String, ... rest):*
  53.         {
  54.             var loc1:*=null;
  55.             var loc2:*=null;
  56.             var loc3:*=false;
  57.             var loc4:*=0;
  58.             var loc5:*=null;
  59.             var loc6:*=null;
  60.             var loc7:*=false;
  61.             var loc8:*=null;
  62.             if (available)
  63.             {
  64.                 loc1 = "";
  65.                 _initJS();
  66.                 loc1 = loc1 + "try { ";
  67.                 loc2 = objectID;
  68.                 loc3 = activeX;
  69.                 if (loc3 == true && !(loc2 == null))
  70.                 {
  71.                     loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(");
  72.                 }
  73.                 loc1 = loc1 + ("__flash__toXML(" + arg1 + "(");
  74.                 loc4 = 0;
  75.                 while (loc4 < rest.length)
  76.                 {
  77.                     if (loc4 != 0)
  78.                     {
  79.                         loc1 = loc1 + ",";
  80.                     }
  81.                     loc1 = loc1 + _toJS(rest[loc4]);
  82.                     ++loc4;
  83.                 }
  84.                 loc1 = loc1 + ")) ";
  85.                 if (loc3 == true && !(loc2 == null))
  86.                 {
  87.                     loc1 = loc1 + ")";
  88.                 }
  89.                 loc1 = loc1 + "; } catch (e) { ";
  90.                 if (loc3 == true && !(loc2 == null))
  91.                 {
  92.                     if (marshallExceptions)
  93.                     {
  94.                         loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(\"<exception>\" + e + \"</exception>\");");
  95.                     }
  96.                     else
  97.                     {
  98.                         loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(\"<undefined/>\");");
  99.                     }
  100.                 }
  101.                 else if (marshallExceptions)
  102.                 {
  103.                     loc1 = loc1 + "\"<exception>\" + e + \"</exception>\";";
  104.                 }
  105.                 else
  106.                 {
  107.                     loc1 = loc1 + "\"<undefined/>\";";
  108.                 }
  109.                 loc1 = loc1 + " }";
  110.                 loc5 = _evalJS(loc1);
  111.                 if (loc5 == null)
  112.                 {
  113.                     loc6 = "<invoke name=\"" + arg1 + "\" returntype=\"xml\">" + _argumentsToXML(rest) + "</invoke>";
  114.                     loc5 = _callOut(loc6);
  115.                 }
  116.                 if (loc5 == null)
  117.                 {
  118.                     return null;
  119.                 }
  120.                 loc7 = XML.ignoreWhitespace;
  121.                 if (Capabilities.version.split(new RegExp("[\\ ,]"))[1] > 9)
  122.                 {
  123.                     XML.ignoreWhitespace = false;
  124.                 }
  125.                 loc8 = XML(loc5);
  126.                 XML.ignoreWhitespace = loc7;
  127.                 return _toAS(loc8);
  128.             }
  129.             Error.throwError(Error, 2067);
  130.             return;
  131.         }
  132.  
  133.         private static function _initJS():void
  134.         {
  135.         }
  136.  
  137.         private static function _getPropNames(arg1:Object):Array
  138.         {
  139.         }
  140.  
  141.         public static function get objectID():String
  142.         {
  143.         }
  144.  
  145.         private static function get activeX():Boolean
  146.         {
  147.         }
  148.  
  149.         private static function _addCallback(arg1:String, arg2:Function, arg3:Boolean):void
  150.         {
  151.         }
  152.  
  153.         private static function _evalJS(arg1:String):String
  154.         {
  155.         }
  156.  
  157.         private static function _callOut(arg1:String):String
  158.         {
  159.         }
  160.  
  161.         private static function _callIn(arg1:Function, arg2:String, arg3:Array):String
  162.         {
  163.             var closure:Function;
  164.             var request:String;
  165.             var args:Array;
  166.             var arguments:Array;
  167.             var oldIgnoreWhitespace:Boolean;
  168.             var xml:XML;
  169.             var result:*;
  170.  
  171.             var loc1:*;
  172.             result = undefined;
  173.             closure = arg1;
  174.             request = arg2;
  175.             args = arg3;
  176.             arguments = arguments;
  177.             if (args != null)
  178.             {
  179.                 try
  180.                 {
  181.                     result = closure.apply(null, args);
  182.                 }
  183.                 catch (e:Error)
  184.                 {
  185.                     if (marshallExceptions)
  186.                     {
  187.                         result = e;
  188.                     }
  189.                     else
  190.                     {
  191.                         throw e;
  192.                     }
  193.                 }
  194.                 return _toJS(result);
  195.             }
  196.             oldIgnoreWhitespace = XML.ignoreWhitespace;
  197.             XML.ignoreWhitespace = false;
  198.             xml = XML(request);
  199.             XML.ignoreWhitespace = oldIgnoreWhitespace;
  200.             try
  201.             {
  202.                 result = closure.apply(null, _argumentsToAS(xml.arguments));
  203.             }
  204.             catch (e:Error)
  205.             {
  206.                 if (marshallExceptions)
  207.                 {
  208.                     result = e;
  209.                 }
  210.                 else
  211.                 {
  212.                     throw e;
  213.                 }
  214.             }
  215.             return xml.@returntype != "javascript" ? _toXML(result) : _toJS(result);
  216.         }
  217.  
  218.         private static function _arrayToXML(arg1:Array):String
  219.         {
  220.             var loc1:*="<array>";
  221.             var loc2:*=0;
  222.             while (loc2 < arg1.length)
  223.             {
  224.                 loc1 = loc1 + ("<property id=\"" + loc2 + "\">" + _toXML(arg1[loc2]) + "</property>");
  225.                 ++loc2;
  226.             }
  227.             return loc1 + "</array>";
  228.         }
  229.  
  230.         private static function _argumentsToXML(arg1:Array):String
  231.         {
  232.             var loc1:*="<arguments>";
  233.             var loc2:*=0;
  234.             while (loc2 < arg1.length)
  235.             {
  236.                 loc1 = loc1 + _toXML(arg1[loc2]);
  237.                 ++loc2;
  238.             }
  239.             return loc1 + "</arguments>";
  240.         }
  241.  
  242.         private static function _objectToXML(arg1:*):String
  243.         {
  244.             var loc2:*=null;
  245.             var loc1:*="<object>";
  246.             var loc3:*=0;
  247.             var loc4:*=arg1;
  248.             for (loc2 in loc4)
  249.             {
  250.                 loc1 = loc1 + ("<property id=\"" + loc2 + "\">" + _toXML(arg1[loc2]) + "</property>");
  251.             }
  252.             return loc1 + "</object>";
  253.         }
  254.  
  255.         private static function _escapeXML(arg1:String):String
  256.         {
  257.             return arg1.replace(new RegExp("&", "g"), "&amp;").replace(new RegExp("<", "g"), "&lt;").replace(new RegExp(">", "g"), "&gt;").replace(new RegExp("\"", "g"), "&quot;").replace(new RegExp("\'", "g"), "&apos;");
  258.         }
  259.  
  260.         private static function _toXML(arg1:*):String
  261.         {
  262.             var loc1:*=typeof arg1;
  263.             if (loc1 == "string")
  264.             {
  265.                 return "<string>" + _escapeXML(arg1) + "</string>";
  266.             }
  267.             if (loc1 == "undefined")
  268.             {
  269.                 return "<undefined/>";
  270.             }
  271.             if (loc1 == "number")
  272.             {
  273.                 return "<number>" + arg1 + "</number>";
  274.             }
  275.             if (arg1 == null)
  276.             {
  277.                 return "<null/>";
  278.             }
  279.             if (loc1 == "boolean")
  280.             {
  281.                 return arg1 ? "<true/>" : "<false/>";
  282.             }
  283.             if (arg1.hasOwnProperty("length"))
  284.             {
  285.                 return _arrayToXML(arg1);
  286.             }
  287.             if (arg1 is Date)
  288.             {
  289.                 return "<date>" + arg1.time + "</date>";
  290.             }
  291.             if (arg1 is Error && marshallExceptions)
  292.             {
  293.                 return "<exception>" + arg1 + "</exception>";
  294.             }
  295.             if (loc1 == "object")
  296.             {
  297.                 return _objectToXML(arg1);
  298.             }
  299.             return "<null/>";
  300.         }
  301.  
  302.         private static function _objectToAS(arg1:Object):*
  303.         {
  304.             var loc2:*=null;
  305.             var loc1:*={};
  306.             var loc3:*=0;
  307.             var loc4:*=arg1.property;
  308.             for each (loc2 in loc4)
  309.             {
  310.                 loc1[loc2.@id] = _toAS(loc2.children());
  311.             }
  312.             return loc1;
  313.         }
  314.  
  315.         private static function _arrayToAS(arg1:Object):*
  316.         {
  317.             var loc2:*=null;
  318.             var loc1:*=[];
  319.             var loc3:*=0;
  320.             var loc4:*=arg1.children();
  321.             for each (loc2 in loc4)
  322.             {
  323.                 loc1[loc2.@id] = _toAS(loc2.children());
  324.             }
  325.             return loc1;
  326.         }
  327.  
  328.         private static function _toAS(arg1:Object):*
  329.         {
  330.             var loc1:*=arg1.name();
  331.             if (loc1 == "number")
  332.             {
  333.                 return Number(arg1.children());
  334.             }
  335.             if (loc1 == "string")
  336.             {
  337.                 return String(arg1.children());
  338.             }
  339.             if (loc1 == "false")
  340.             {
  341.                 return false;
  342.             }
  343.             if (loc1 == "true")
  344.             {
  345.                 return true;
  346.             }
  347.             if (loc1 == "null")
  348.             {
  349.                 return null;
  350.             }
  351.             if (loc1 == "undefined")
  352.             {
  353.                 return undefined;
  354.             }
  355.             if (loc1 == "date")
  356.             {
  357.                 return new Date(Number(arg1.children()));
  358.             }
  359.             if (loc1 == "object")
  360.             {
  361.                 return _objectToAS(arg1);
  362.             }
  363.             if (loc1 == "array")
  364.             {
  365.                 return _arrayToAS(arg1);
  366.             }
  367.             if (loc1 == "class")
  368.             {
  369.                 return getDefinitionByName(String(arg1.children()));
  370.             }
  371.             if (loc1 == "exception" && marshallExceptions)
  372.             {
  373.                 throw new Error(arg1.children());
  374.             }
  375.             return undefined;
  376.         }
  377.  
  378.         private static function _argumentsToAS(arg1:*):Array
  379.         {
  380.             var loc2:*=null;
  381.             var loc1:*=[];
  382.             var loc3:*=0;
  383.             var loc4:*=arg1.children();
  384.             for each (loc2 in loc4)
  385.             {
  386.                 loc1.push(_toAS(loc2));
  387.             }
  388.             return loc1;
  389.         }
  390.  
  391.         private static function _arrayToJS(arg1:Array):String
  392.         {
  393.             var loc1:*="[";
  394.             var loc2:*=0;
  395.             while (loc2 < arg1.length)
  396.             {
  397.                 if (loc2 != 0)
  398.                 {
  399.                     loc1 = loc1 + ",";
  400.                 }
  401.                 loc1 = loc1 + _toJS(arg1[loc2]);
  402.                 ++loc2;
  403.             }
  404.             return loc1 + "]";
  405.         }
  406.  
  407.         private static function _objectToJS(arg1:*):String
  408.         {
  409.             var loc1:*=_getPropNames(arg1);
  410.             var loc2:*="({";
  411.             var loc3:*=0;
  412.             while (loc3 < loc1.length)
  413.             {
  414.                 if (loc3 > 0)
  415.                 {
  416.                     loc2 = loc2 + ",";
  417.                 }
  418.                 loc2 = loc2 + (loc1[loc3] + ":" + _toJS(arg1[loc1[loc3]]));
  419.                 ++loc3;
  420.             }
  421.             return loc2 + "})";
  422.         }
  423.  
  424.         private static function _toJS(arg1:*):String
  425.         {
  426.             if (arg1 is Error && marshallExceptions)
  427.             {
  428.                 return "throw \"" + arg1 + "\"";
  429.             }
  430.             if (typeof arg1 == "string")
  431.             {
  432.                 return "\"" + arg1.replace(new RegExp("\\\"", "g"), "\\\"").replace(new RegExp("\\n", "g"), "\\n").replace(new RegExp("\\r", "g"), "\\r") + "\"";
  433.             }
  434.             if (arg1 === null)
  435.             {
  436.                 return "null";
  437.             }
  438.             if (arg1 is Date)
  439.             {
  440.                 return "new Date (" + arg1.time + ")";
  441.             }
  442.             if (typeof arg1 == "object")
  443.             {
  444.                 if (arg1 is Array)
  445.                 {
  446.                     return _arrayToJS(arg1);
  447.                 }
  448.                 return _objectToJS(arg1);
  449.             }
  450.             return String(arg1);
  451.         }
  452.  
  453.        
  454.         {
  455.             marshallExceptions = false;
  456.         }
  457.  
  458.         public static var marshallExceptions:Boolean=false;
  459.     }
  460. }
clone this paste RAW Paste Data