home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / mirrored_maze2.swf / scripts / __Packages / MochiAd.as
Text File  |  2008-09-04  |  20KB  |  652 lines
  1. class MochiAd
  2. {
  3.    function MochiAd()
  4.    {
  5.    }
  6.    static function getVersion()
  7.    {
  8.       return "2.5";
  9.    }
  10.    static function showPreGameAd(options)
  11.    {
  12.       var _loc26_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,no_progress_bar:false,ad_started:function()
  13.       {
  14.          this.clip.stop();
  15.       },ad_finished:function()
  16.       {
  17.          this.clip.play();
  18.       },ad_failed:function()
  19.       {
  20.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  21.       },ad_loaded:function(width, height)
  22.       {
  23.       },ad_skipped:function()
  24.       {
  25.       },ad_progress:function(percent)
  26.       {
  27.       }};
  28.       options = MochiAd._parseOptions(options,_loc26_);
  29.       if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
  30.       {
  31.          options.ad_started();
  32.          options.ad_finished();
  33.          return undefined;
  34.       }
  35.       var clip = options.clip;
  36.       var _loc22_ = 11000;
  37.       var _loc25_ = options.ad_timeout;
  38.       delete options.ad_timeout;
  39.       var fadeout_time = options.fadeout_time;
  40.       delete options.fadeout_time;
  41.       if(!MochiAd.load(options))
  42.       {
  43.          options.ad_failed();
  44.          options.ad_finished();
  45.          return undefined;
  46.       }
  47.       options.ad_started();
  48.       var mc = clip._mochiad;
  49.       mc.onUnload = function()
  50.       {
  51.          options.ad_finished();
  52.       };
  53.       var _loc14_ = MochiAd._getRes(options);
  54.       var _loc4_ = _loc14_[0];
  55.       var _loc13_ = _loc14_[1];
  56.       mc._x = _loc4_ * 0.5;
  57.       mc._y = _loc13_ * 0.5;
  58.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  59.       chk._x = _loc4_ * -0.5;
  60.       chk._y = _loc13_ * -0.5;
  61.       var _loc6_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  62.       if(options.no_progress_bar)
  63.       {
  64.          _loc6_._visible = false;
  65.          delete options.no_progress_bar;
  66.       }
  67.       else
  68.       {
  69.          _loc6_._x = 10;
  70.          _loc6_._y = _loc13_ - 20;
  71.       }
  72.       var _loc21_ = options.color;
  73.       delete options.color;
  74.       var _loc19_ = options.background;
  75.       delete options.background;
  76.       var _loc23_ = options.outline;
  77.       delete options.outline;
  78.       var _loc5_ = _loc6_.createEmptyMovieClip("_outline",1);
  79.       _loc5_.beginFill(_loc19_);
  80.       _loc5_.moveTo(0,0);
  81.       _loc5_.lineTo(_loc4_ - 20,0);
  82.       _loc5_.lineTo(_loc4_ - 20,10);
  83.       _loc5_.lineTo(0,10);
  84.       _loc5_.lineTo(0,0);
  85.       _loc5_.endFill();
  86.       var _loc3_ = _loc6_.createEmptyMovieClip("_inside",2);
  87.       _loc3_.beginFill(_loc21_);
  88.       _loc3_.moveTo(0,0);
  89.       _loc3_.lineTo(_loc4_ - 20,0);
  90.       _loc3_.lineTo(_loc4_ - 20,10);
  91.       _loc3_.lineTo(0,10);
  92.       _loc3_.lineTo(0,0);
  93.       _loc3_.endFill();
  94.       _loc3_._xscale = 0;
  95.       var _loc7_ = _loc6_.createEmptyMovieClip("_outline",3);
  96.       _loc7_.lineStyle(0,_loc23_,100);
  97.       _loc7_.moveTo(0,0);
  98.       _loc7_.lineTo(_loc4_ - 20,0);
  99.       _loc7_.lineTo(_loc4_ - 20,10);
  100.       _loc7_.lineTo(0,10);
  101.       _loc7_.lineTo(0,0);
  102.       chk.ad_msec = _loc22_;
  103.       chk.ad_timeout = _loc25_;
  104.       chk.started = getTimer();
  105.       chk.showing = false;
  106.       chk.last_pcnt = 0;
  107.       chk.fadeout_time = fadeout_time;
  108.       chk.fadeFunction = function()
  109.       {
  110.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  111.          if(_loc2_ > 0)
  112.          {
  113.             this._parent._alpha = _loc2_;
  114.          }
  115.          else
  116.          {
  117.             var _loc3_ = this._parent._parent;
  118.             MochiAd.unload(_loc3_);
  119.             delete this.onEnterFrame;
  120.          }
  121.       };
  122.       mc.lc.regContLC = function(lc_name)
  123.       {
  124.          mc._containerLCName = lc_name;
  125.       };
  126.       var sendHostProgress = false;
  127.       mc.lc.sendHostLoadProgress = function(lc_name)
  128.       {
  129.          sendHostProgress = true;
  130.       };
  131.       mc.lc.adLoaded = options.ad_loaded;
  132.       mc.lc.adSkipped = options.ad_skipped;
  133.       mc.lc.adjustProgress = function(msec)
  134.       {
  135.          var _loc2_ = this.mc._mochiad_wait;
  136.          _loc2_.server_control = true;
  137.          _loc2_.started = getTimer();
  138.          _loc2_.ad_msec = msec;
  139.       };
  140.       mc.lc.rpc = function(callbackID, arg)
  141.       {
  142.          MochiAd.rpc(clip,callbackID,arg);
  143.       };
  144.       mc.rpcTestFn = function(s)
  145.       {
  146.          trace("[MOCHIAD rpcTestFn] " + s);
  147.          return s;
  148.       };
  149.       chk.onEnterFrame = function()
  150.       {
  151.          var _loc6_ = this._parent._parent;
  152.          var _loc11_ = this._parent._mochiad_ctr;
  153.          var _loc5_ = getTimer() - this.started;
  154.          var _loc3_ = false;
  155.          var _loc4_ = _loc6_.getBytesTotal();
  156.          var _loc8_ = _loc6_.getBytesLoaded();
  157.          var _loc2_ = 100 * _loc8_ / _loc4_;
  158.          var _loc10_ = 100 * _loc5_ / chk.ad_msec;
  159.          var _loc9_ = this._mochiad_bar._inside;
  160.          var _loc13_ = Math.min(100,Math.min(_loc2_ || 0,_loc10_));
  161.          _loc13_ = Math.max(this.last_pcnt,_loc13_);
  162.          this.last_pcnt = _loc13_;
  163.          _loc9_._xscale = _loc13_;
  164.          options.ad_progress(_loc13_);
  165.          if(sendHostProgress)
  166.          {
  167.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"hostLoadPcnt",pcnt:_loc2_});
  168.             if(_loc2_ == 100)
  169.             {
  170.                sendHostProgress = false;
  171.             }
  172.          }
  173.          if(!chk.showing)
  174.          {
  175.             var _loc7_ = _loc11_.getBytesTotal();
  176.             if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  177.             {
  178.                chk.showing = true;
  179.                chk.started = getTimer();
  180.             }
  181.             else if(_loc5_ > chk.ad_timeout && _loc2_ == 100)
  182.             {
  183.                options.ad_failed();
  184.                _loc3_ = true;
  185.             }
  186.          }
  187.          if(_loc5_ > chk.ad_msec)
  188.          {
  189.             _loc3_ = true;
  190.          }
  191.          if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  192.          {
  193.             if(this.server_control)
  194.             {
  195.                delete this.onEnterFrame;
  196.             }
  197.             else
  198.             {
  199.                this.fadeout_start = getTimer();
  200.                this.onEnterFrame = chk.fadeFunction;
  201.             }
  202.          }
  203.       };
  204.    }
  205.    static function showClickAwayAd(options)
  206.    {
  207.       var _loc9_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showClickAwayAd",res:"300x250",no_bg:true,ad_started:function()
  208.       {
  209.       },ad_finished:function()
  210.       {
  211.       },ad_loaded:function(width, height)
  212.       {
  213.       },ad_failed:function()
  214.       {
  215.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  216.       },ad_skipped:function()
  217.       {
  218.       }};
  219.       options = MochiAd._parseOptions(options,_loc9_);
  220.       var clip = options.clip;
  221.       var _loc8_ = options.ad_timeout;
  222.       delete options.ad_timeout;
  223.       if(!MochiAd.load(options))
  224.       {
  225.          options.ad_failed();
  226.          options.ad_finished();
  227.          return undefined;
  228.       }
  229.       options.ad_started();
  230.       var mc = clip._mochiad;
  231.       mc.onUnload = function()
  232.       {
  233.          options.ad_finished();
  234.       };
  235.       var _loc4_ = MochiAd._getRes(options);
  236.       var _loc10_ = _loc4_[0];
  237.       var _loc7_ = _loc4_[1];
  238.       mc._x = _loc10_ * 0.5;
  239.       mc._y = _loc7_ * 0.5;
  240.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  241.       chk.ad_timeout = _loc8_;
  242.       chk.started = getTimer();
  243.       chk.showing = false;
  244.       mc.lc.adLoaded = options.ad_loaded;
  245.       mc.lc.adSkipped = options.ad_skipped;
  246.       mc.lc.rpc = function(callbackID, arg)
  247.       {
  248.          MochiAd.rpc(clip,callbackID,arg);
  249.       };
  250.       mc.rpcTestFn = function(s)
  251.       {
  252.          trace("[MOCHIAD rpcTestFn] " + s);
  253.          return s;
  254.       };
  255.       var _loc20_ = false;
  256.       mc.lc.regContLC = function(lc_name)
  257.       {
  258.          mc._containerLCName = lc_name;
  259.       };
  260.       chk.onEnterFrame = function()
  261.       {
  262.          var _loc5_ = this._parent._mochiad_ctr;
  263.          var _loc4_ = getTimer() - this.started;
  264.          var _loc2_ = false;
  265.          if(!chk.showing)
  266.          {
  267.             var _loc3_ = _loc5_.getBytesTotal();
  268.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  269.             {
  270.                _loc2_ = true;
  271.                chk.showing = true;
  272.                chk.started = getTimer();
  273.             }
  274.             else if(_loc4_ > chk.ad_timeout)
  275.             {
  276.                options.ad_failed();
  277.                _loc2_ = true;
  278.             }
  279.          }
  280.          if(_loc2_)
  281.          {
  282.             delete this.onEnterFrame;
  283.          }
  284.       };
  285.    }
  286.    static function showInterLevelAd(options)
  287.    {
  288.       var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  289.       {
  290.          this.clip.stop();
  291.       },ad_finished:function()
  292.       {
  293.          this.clip.play();
  294.       },ad_failed:function()
  295.       {
  296.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  297.       },ad_loaded:function(width, height)
  298.       {
  299.       },ad_skipped:function()
  300.       {
  301.       }};
  302.       options = MochiAd._parseOptions(options,_loc13_);
  303.       var clip = options.clip;
  304.       var _loc10_ = 11000;
  305.       var _loc12_ = options.ad_timeout;
  306.       delete options.ad_timeout;
  307.       var fadeout_time = options.fadeout_time;
  308.       delete options.fadeout_time;
  309.       if(!MochiAd.load(options))
  310.       {
  311.          options.ad_failed();
  312.          options.ad_finished();
  313.          return undefined;
  314.       }
  315.       options.ad_started();
  316.       var mc = clip._mochiad;
  317.       mc.onUnload = function()
  318.       {
  319.          options.ad_finished();
  320.       };
  321.       var _loc5_ = MochiAd._getRes(options);
  322.       var _loc14_ = _loc5_[0];
  323.       var _loc11_ = _loc5_[1];
  324.       mc._x = _loc14_ * 0.5;
  325.       mc._y = _loc11_ * 0.5;
  326.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  327.       chk.ad_msec = _loc10_;
  328.       chk.ad_timeout = _loc12_;
  329.       chk.started = getTimer();
  330.       chk.showing = false;
  331.       chk.fadeout_time = fadeout_time;
  332.       chk.fadeFunction = function()
  333.       {
  334.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  335.          if(_loc2_ > 0)
  336.          {
  337.             this._parent._alpha = _loc2_;
  338.          }
  339.          else
  340.          {
  341.             var _loc3_ = this._parent._parent;
  342.             MochiAd.unload(_loc3_);
  343.             delete this.onEnterFrame;
  344.          }
  345.       };
  346.       mc.lc.adLoaded = options.ad_loaded;
  347.       mc.lc.adSkipped = options.ad_skipped;
  348.       mc.lc.adjustProgress = function(msec)
  349.       {
  350.          var _loc2_ = this.mc._mochiad_wait;
  351.          _loc2_.server_control = true;
  352.          _loc2_.started = getTimer();
  353.          _loc2_.ad_msec = msec - 250;
  354.       };
  355.       mc.lc.rpc = function(callbackID, arg)
  356.       {
  357.          MochiAd.rpc(clip,callbackID,arg);
  358.       };
  359.       mc.rpcTestFn = function(s)
  360.       {
  361.          trace("[MOCHIAD rpcTestFn] " + s);
  362.          return s;
  363.       };
  364.       chk.onEnterFrame = function()
  365.       {
  366.          var _loc5_ = this._parent._mochiad_ctr;
  367.          var _loc4_ = getTimer() - this.started;
  368.          var _loc2_ = false;
  369.          if(!chk.showing)
  370.          {
  371.             var _loc3_ = _loc5_.getBytesTotal();
  372.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  373.             {
  374.                chk.showing = true;
  375.                chk.started = getTimer();
  376.             }
  377.             else if(_loc4_ > chk.ad_timeout)
  378.             {
  379.                options.ad_failed();
  380.                _loc2_ = true;
  381.             }
  382.          }
  383.          if(_loc4_ > chk.ad_msec)
  384.          {
  385.             _loc2_ = true;
  386.          }
  387.          if(_loc2_)
  388.          {
  389.             if(this.server_control)
  390.             {
  391.                delete this.onEnterFrame;
  392.             }
  393.             else
  394.             {
  395.                this.fadeout_start = getTimer();
  396.                this.onEnterFrame = this.fadeFunction;
  397.             }
  398.          }
  399.       };
  400.    }
  401.    static function showPreloaderAd(options)
  402.    {
  403.       trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
  404.       MochiAd.showPreGameAd(options);
  405.    }
  406.    static function showTimedAd(options)
  407.    {
  408.       trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
  409.       MochiAd.showInterLevelAd(options);
  410.    }
  411.    static function _allowDomains(server)
  412.    {
  413.       var _loc1_ = server.split("/")[2].split(":")[0];
  414.       if(System.security)
  415.       {
  416.          if(System.security.allowDomain)
  417.          {
  418.             System.security.allowDomain("*");
  419.             System.security.allowDomain(_loc1_);
  420.          }
  421.          if(System.security.allowInsecureDomain)
  422.          {
  423.             System.security.allowInsecureDomain("*");
  424.             System.security.allowInsecureDomain(_loc1_);
  425.          }
  426.       }
  427.       return _loc1_;
  428.    }
  429.    static function load(options)
  430.    {
  431.       var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  432.       options = MochiAd._parseOptions(options,_loc13_);
  433.       options.swfv = options.clip.getSWFVersion() || 6;
  434.       options.mav = MochiAd.getVersion();
  435.       var _loc9_ = options.clip;
  436.       if(!MochiAd._isNetworkAvailable())
  437.       {
  438.          return null;
  439.       }
  440.       if(_loc9_._mochiad_loaded)
  441.       {
  442.          return null;
  443.       }
  444.       var _loc12_ = options.depth;
  445.       delete options.depth;
  446.       var _loc6_ = _loc9_.createEmptyMovieClip("_mochiad",_loc12_);
  447.       var _loc11_ = MochiAd._getRes(options);
  448.       options.res = _loc11_[0] + "x" + _loc11_[1];
  449.       options.server += options.id;
  450.       delete options.id;
  451.       _loc9_._mochiad_loaded = true;
  452.       var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  453.       for(var _loc7_ in options)
  454.       {
  455.          _loc4_[_loc7_] = options[_loc7_];
  456.       }
  457.       var _loc10_ = _loc4_.server;
  458.       delete _loc4_.server;
  459.       var _loc14_ = MochiAd._allowDomains(_loc10_);
  460.       _loc6_.onEnterFrame = function()
  461.       {
  462.          if(this._mochiad_ctr._url != this._url)
  463.          {
  464.             this.onEnterFrame = function()
  465.             {
  466.                if(!this._mochiad_ctr)
  467.                {
  468.                   delete this.onEnterFrame;
  469.                   MochiAd.unload(this._parent);
  470.                }
  471.             };
  472.          }
  473.       };
  474.       var _loc5_ = new LocalConnection();
  475.       var _loc8_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  476.       _loc5_.mc = _loc6_;
  477.       _loc5_.name = _loc8_;
  478.       _loc5_.hostname = _loc14_;
  479.       _loc5_.allowDomain = function(d)
  480.       {
  481.          return true;
  482.       };
  483.       _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  484.       _loc5_.connect(_loc8_);
  485.       _loc6_.lc = _loc5_;
  486.       _loc4_.lc = _loc8_;
  487.       _loc4_.st = getTimer();
  488.       _loc4_.loadMovie(_loc10_ + ".swf","POST");
  489.       return _loc6_;
  490.    }
  491.    static function unload(clip)
  492.    {
  493.       if(typeof clip == "undefined")
  494.       {
  495.          clip = _root;
  496.       }
  497.       if(clip.clip && clip.clip._mochiad)
  498.       {
  499.          clip = clip.clip;
  500.       }
  501.       if(!clip._mochiad)
  502.       {
  503.          return false;
  504.       }
  505.       if(clip._mochiad._containerLCName != undefined)
  506.       {
  507.          clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"unload"});
  508.       }
  509.       clip._mochiad.removeMovieClip();
  510.       delete clip._mochiad_loaded;
  511.       delete clip._mochiad;
  512.       return true;
  513.    }
  514.    static function _isNetworkAvailable()
  515.    {
  516.       if(System.security)
  517.       {
  518.          var _loc1_ = System.security;
  519.          if(_loc1_.sandboxType == "localWithFile")
  520.          {
  521.             return false;
  522.          }
  523.       }
  524.       return true;
  525.    }
  526.    static function _getRes(options)
  527.    {
  528.       var _loc3_ = options.clip.getBounds();
  529.       var _loc2_ = 0;
  530.       var _loc1_ = 0;
  531.       if(typeof options.res != "undefined")
  532.       {
  533.          var _loc4_ = options.res.split("x");
  534.          _loc2_ = parseFloat(_loc4_[0]);
  535.          _loc1_ = parseFloat(_loc4_[1]);
  536.       }
  537.       else
  538.       {
  539.          _loc2_ = _loc3_.xMax - _loc3_.xMin;
  540.          _loc1_ = _loc3_.yMax - _loc3_.yMin;
  541.       }
  542.       if(_loc2_ == 0 || _loc1_ == 0)
  543.       {
  544.          _loc2_ = Stage.width;
  545.          _loc1_ = Stage.height;
  546.       }
  547.       return [_loc2_,_loc1_];
  548.    }
  549.    static function _parseOptions(options, defaults)
  550.    {
  551.       var _loc4_ = {};
  552.       for(var _loc8_ in defaults)
  553.       {
  554.          _loc4_[_loc8_] = defaults[_loc8_];
  555.       }
  556.       if(options)
  557.       {
  558.          for(_loc8_ in options)
  559.          {
  560.             _loc4_[_loc8_] = options[_loc8_];
  561.          }
  562.       }
  563.       if(_root.mochiad_options)
  564.       {
  565.          var _loc5_ = _root.mochiad_options.split("&");
  566.          var _loc2_ = 0;
  567.          while(_loc2_ < _loc5_.length)
  568.          {
  569.             var _loc3_ = _loc5_[_loc2_].split("=");
  570.             _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  571.             _loc2_ = _loc2_ + 1;
  572.          }
  573.       }
  574.       if(_loc4_.id == "test")
  575.       {
  576.          trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
  577.       }
  578.       return _loc4_;
  579.    }
  580.    static function rpc(clip, callbackID, arg)
  581.    {
  582.       switch(arg.id)
  583.       {
  584.          case "setValue":
  585.             MochiAd.setValue(clip,arg.objectName,arg.value);
  586.             break;
  587.          case "getValue":
  588.             var _loc4_ = MochiAd.getValue(clip,arg.objectName);
  589.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc4_);
  590.             break;
  591.          case "runMethod":
  592.             var _loc3_ = MochiAd.runMethod(clip,arg.method,arg.args);
  593.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc3_);
  594.             break;
  595.          default:
  596.             trace("[mochiads rpc] unknown rpc id: " + arg.id);
  597.       }
  598.    }
  599.    static function setValue(base, objectName, value)
  600.    {
  601.       var _loc2_ = objectName.split(".");
  602.       var _loc1_ = undefined;
  603.       _loc1_ = 0;
  604.       while(_loc1_ < _loc2_.length - 1)
  605.       {
  606.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  607.          {
  608.             return undefined;
  609.          }
  610.          base = base[_loc2_[_loc1_]];
  611.          _loc1_ = _loc1_ + 1;
  612.       }
  613.       base[_loc2_[_loc1_]] = value;
  614.    }
  615.    static function getValue(base, objectName)
  616.    {
  617.       var _loc2_ = objectName.split(".");
  618.       var _loc1_ = undefined;
  619.       _loc1_ = 0;
  620.       while(_loc1_ < _loc2_.length - 1)
  621.       {
  622.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  623.          {
  624.             return undefined;
  625.          }
  626.          base = base[_loc2_[_loc1_]];
  627.          _loc1_ = _loc1_ + 1;
  628.       }
  629.       return base[_loc2_[_loc1_]];
  630.    }
  631.    static function runMethod(base, methodName, argsArray)
  632.    {
  633.       var _loc2_ = methodName.split(".");
  634.       var _loc1_ = undefined;
  635.       _loc1_ = 0;
  636.       while(_loc1_ < _loc2_.length - 1)
  637.       {
  638.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  639.          {
  640.             return undefined;
  641.          }
  642.          base = base[_loc2_[_loc1_]];
  643.          _loc1_ = _loc1_ + 1;
  644.       }
  645.       if(typeof base[_loc2_[_loc1_]] == "function")
  646.       {
  647.          return base[_loc2_[_loc1_]].apply(base,argsArray);
  648.       }
  649.       return undefined;
  650.    }
  651. }
  652.