AS3: How to load child swf in parent swf at run-time

Here is a class to load single or multiple external/child swf files in the main/parent swf at run-time.

CODE

 package   
 {  
  import flash.display.Sprite;  
  import flash.display.Loader;  
  import flash.display.MovieClip;  
  import flash.net.URLRequest;  
  import flash.events.Event;  
  import flash.events.IEventDispatcher;  
  import flash.events.ProgressEvent;  
  import flash.events.SecurityErrorEvent;  
  import flash.events.HTTPStatusEvent;  
  import flash.events.IOErrorEvent;  
  /**  
   * @file CSwfLoader.as  
   * @author Abhishek Kumar  
   */  
  public class CSwfLoader   
  {  
   public var _Proceed:Function;  
   private var swfLoader:Loader;  
   private var swfRequest:URLRequest;  
   private var swfPathList:Array;  
   private var swfList:Array = [];  
   private var swfTemp:MovieClip;  
   private var swfCount:int; 
 
   public function CSwfLoader()   
   {  
    swfLoader = new Loader();  
    swfRequest = new URLRequest();     
   }  

   public function startLoading(swfPaths:Array):void   
   {  
    swfPathList = swfPaths;  
    loadSWF(swfPathList[0]);  
   }  

   private function loadSWF(path:String):void   
   {  
    initiateListeners(swfLoader.contentLoaderInfo);  
    swfRequest.url = path;  
    swfLoader.load(swfRequest);  
   }  

   private function initiateListeners (dispatcher:IEventDispatcher):void  
   {  
    trace ("CSwfLoader -> initiateListeners: ");  
    dispatcher.addEventListener (Event.COMPLETE, completeHandler);  
    dispatcher.addEventListener (Event.OPEN, openHandler);  
    dispatcher.addEventListener (ProgressEvent.PROGRESS, progressHandler);  
    dispatcher.addEventListener (SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);  
    dispatcher.addEventListener (HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);  
    dispatcher.addEventListener (IOErrorEvent.IO_ERROR, ioErrorHandler);  
   }  

   private function destroyListeners (dispatcher:IEventDispatcher):void  
   {  
    trace ("CSwfLoader -> destroyListeners: ");  
    dispatcher.removeEventListener (Event.COMPLETE, completeHandler);  
    dispatcher.removeEventListener (Event.OPEN, openHandler);  
    dispatcher.removeEventListener (ProgressEvent.PROGRESS, progressHandler);  
    dispatcher.removeEventListener (SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);  
    dispatcher.removeEventListener (HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);  
    dispatcher.removeEventListener (IOErrorEvent.IO_ERROR, ioErrorHandler);  
   }  

   private function completeHandler (event:Event):void  
   {  
    trace ("CSwfLoader -> completeHandler: " + event);  
    destroyListeners(swfLoader.contentLoaderInfo);  
    swfTemp = event.target.content as MovieClip;  
    swfTemp.customID = swfCount;  
    swfList.push(swfTemp);  
    if (swfCount < swfPathList.length - 1)  
    {   
     swfCount++;  
     initiateListeners(swfLoader.contentLoaderInfo);  
     loadSWF(swfPathList[swfCount]);  
    }  
    else  
    {   
     swfLoader.unload();  
     swfLoader = null;   
     _Proceed (swfList);   
    }  
   }   

   private function openHandler (event:Event):void   
   {   
    trace ("CSwfLoader -> openHandler: " + event);  
   }  

   private function progressHandler (event:ProgressEvent):void  
   {  
    trace ("CSwfLoader -> progressHandler loaded:" + event.bytesLoaded + " total: " + event.bytesTotal);  
   }  

   private function securityErrorHandler (event:SecurityErrorEvent):void  
   {  
    trace ("CSwfLoader -> securityErrorHandler: " + event);  
   }  

   private function httpStatusHandler (event:HTTPStatusEvent):void  
   {  
    trace ("CSwfLoader -> httpStatusHandler: " + event);  
   }  

   private function ioErrorHandler (event:IOErrorEvent):void  
   {  
    trace ("CSwfLoader -> ioErrorHandler: " + event);  
   }  
  }  
 }  

USAGE

 package   
 {  
  import flash.display.MovieClip;  
  import flash.events.Event;  
  import flash.events.MouseEvent;  
  /**  
   * @file Main.as  
   * @author Abhishek Kumar  
   */  
  public class Main extends MovieClip  
  {  
   private var _swfPathArr:Array = [  
    '../asset/swf_1.swf',  
    '../asset/swf_2.swf',  
    '../asset/swf_3.swf',  
    '../asset/swf_4.swf',  
    '../asset/swf_5.swf',  
    '../asset/swf_6.swf'  
   ];  

   private var _swfClipsArr:Array = [];
  
   public function Main()   
   {  
    var oSwfLoader:CSwfLoader = new CSwfLoader();  
    oSwfLoader._Proceed = onCompletePreloading;  
    oSwfLoader.startLoading(_swfPathArr);  
   }  

   private function onCompletePreloading(list:Array):void   
   {  
    _swfClipsArr = list;  

    btn1_mc.buttonMode = true;  
    btn2_mc.buttonMode = true;  
    btn3_mc.buttonMode = true;  
    btn4_mc.buttonMode = true;  
    btn5_mc.buttonMode = true;  
    btn6_mc.buttonMode = true;  

    btn1_mc.addEventListener(MouseEvent.CLICK, setContent);  
    btn2_mc.addEventListener(MouseEvent.CLICK, setContent);  
    btn3_mc.addEventListener(MouseEvent.CLICK, setContent);  
    btn4_mc.addEventListener(MouseEvent.CLICK, setContent);  
    btn5_mc.addEventListener(MouseEvent.CLICK, setContent);  
    btn6_mc.addEventListener(MouseEvent.CLICK, setContent);  
   }  

   private function setContent(event:MouseEvent):void   
   {  
    var _swfToAdd:MovieClip;  
    switch(event.target.name)   
    {  
     case "btn1_mc": _swfToAdd = _swfClipsArr[0] as MovieClip; break;  
     case "btn2_mc": _swfToAdd = _swfClipsArr[1] as MovieClip; break;  
     case "btn3_mc": _swfToAdd = _swfClipsArr[2] as MovieClip; break;  
     case "btn4_mc": _swfToAdd = _swfClipsArr[3] as MovieClip; break;  
     case "btn5_mc": _swfToAdd = _swfClipsArr[4] as MovieClip; break;  
     case "btn6_mc": _swfToAdd = _swfClipsArr[5] as MovieClip; break;  
    }  
    contentContainer.removeChildAt(contentContainer.numChildren-1);  
    contentContainer.addChild(_swfToAdd);
  
    //Ex: How to access internal movieclips of loaded swf  
    _swfToAdd.title_mc.visible = false;  
    trace(_swfToAdd.customID);  
   }  
  }  
 }