function uniqid(prefix:String):String{
        return prefix + (new Date()).getTime() + Math.random()*0xFFFFFF;
}

var min:int;
var max:int;
var posY:Number;
var centerY:Number = 0;
var dif:Number = 0;

function _startMouse():void { addEventListener(Event.ENTER_FRAME, _ef); }
function _ef(evt:Event):void {
        max = -(_container.height - stage.stageHeight);
        centerY = int(stage.stageHeight / 2);
        dif = centerY - mouseY;
        posY = _container.y + dif * 0.4;
        _moveC();
}

function _moveC():void {
        if (posY <= max) {
                posY = max;
        } else if (posY >= min) {
                posY = min;
        }
        _container.y = _container.y + (posY - _container.y) / 12;
}

_startMouse();

package
{

        import flash.display.MovieClip;

        import flash.events.Event;
        import flash.events.HTTPStatusEvent;
        import flash.events.IEventDispatcher;
        import flash.events.IOErrorEvent;
        import flash.events.SecurityErrorEvent;
       
        import flash.system.ApplicationDomain;
       
        import org.casalib.events.LoadEvent;
        import org.casalib.load.DataLoad;
        import org.casalib.load.GroupLoad;
        import org.casalib.load.SwfLoad;

        public class Main extends MovieClip
        {
               
                protected var _groupLoad:GroupLoad;
                protected var _groupLoadSwfContent:SwfLoad;
                protected var _groupLoadSwfFooter:SwfLoad;
                protected var _groupLoadSwfHeader:SwfLoad;
                protected var _groupLoadSwfMenu:SwfLoad;
                protected var _groupLoadSwfSound:SwfLoad;
                protected var _groupLoadXmlData:DataLoad;
               
                protected const CONTENT_SWF_PATH:String = ’swf/content.swf’;
                protected const FOOTER_SWF_PATH:String = ’swf/footer.swf’;
                protected const HEADER_SWF_PATH:String = ’swf/header.swf’;
                protected const MENU_SWF_PATH:String = ’swf/menu.swf’;
                protected const SOUND_SWF_PATH:String = ’swf/sound.swf’;
                protected const DATA_XML_PATH:String = ‘xml/data.xml’;
               
                protected var domainContent:ApplicationDomain;
                protected var domainFooter:ApplicationDomain;
                protected var domainHeader:ApplicationDomain;
                protected var domainMenu:ApplicationDomain;
                protected var domainSound:ApplicationDomain;
               
                protected var xmlData:XML = new XML();
               
                public function Main():void
                {       
                        _groupLoadSwfContent = new SwfLoad(CONTENT_SWF_PATH);
                        _groupLoadSwfFooter = new SwfLoad(FOOTER_SWF_PATH);
                        _groupLoadSwfHeader = new SwfLoad(HEADER_SWF_PATH);
                        _groupLoadSwfMenu = new SwfLoad(MENU_SWF_PATH);
                        _groupLoadSwfSound = new SwfLoad(SOUND_SWF_PATH);
                        _groupLoadXmlData = new DataLoad(DATA_XML_PATH);
                       
                        _groupLoad = new GroupLoad();
                        _groupLoad.addLoad(_groupLoadSwfContent);
                        _groupLoad.addLoad(_groupLoadSwfFooter);
                        _groupLoad.addLoad(_groupLoadSwfHeader);
                        _groupLoad.addLoad(_groupLoadSwfMenu);
                        _groupLoad.addLoad(_groupLoadSwfSound);
                        _groupLoad.addLoad(_groupLoadXmlData);
                        addGroupLoadDispatcher(_groupLoad);
                        _groupLoad.start();
                }
               
                protected function addGroupLoadDispatcher(dispatcher:IEventDispatcher):void
                {       
                        dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, _groupLoadSecurityError);
                        dispatcher.addEventListener(IOErrorEvent.IO_ERROR, _groupLoadIoError);
                        dispatcher.addEventListener(HTTPStatusEvent.HTTP_STATUS, _groupLoadHttpStatus);
                        dispatcher.addEventListener(LoadEvent.PROGRESS, _groupLoadProgress);
                        dispatcher.addEventListener(LoadEvent.COMPLETE, _groupLoadComplete);
        }
               
                protected function removeGroupLoadDispatcher(dispatcher:IEventDispatcher):void
                {
                        dispatcher.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, _groupLoadSecurityError);
                        dispatcher.removeEventListener(IOErrorEvent.IO_ERROR, _groupLoadIoError);
                        dispatcher.removeEventListener(HTTPStatusEvent.HTTP_STATUS, _groupLoadHttpStatus);
                        dispatcher.removeEventListener(LoadEvent.PROGRESS, _groupLoadProgress);
                        dispatcher.removeEventListener(LoadEvent.COMPLETE, _groupLoadComplete);
        }
               
                protected function _groupLoadSecurityError(evt:Event):void { trace(’securityError: ‘+evt); }
                protected function _groupLoadIoError(evt:Event):void { trace(‘ioError: ‘+evt); }
                protected function _groupLoadHttpStatus(evt:Event):void { trace(‘httpStatus: ‘+evt); }
                protected function _groupLoadProgress(evt:LoadEvent):void { trace(‘%: ‘+evt.progress.percentage); }
                protected function _groupLoadComplete(evt:LoadEvent):void
                {
                        domainContent = _groupLoadSwfContent.loader.contentLoaderInfo.applicationDomain;
                        domainFooter = _groupLoadSwfFooter.loader.contentLoaderInfo.applicationDomain;
                        domainHeader = _groupLoadSwfHeader.loader.contentLoaderInfo.applicationDomain;
                        domainMenu = _groupLoadSwfMenu.loader.contentLoaderInfo.applicationDomain;
                        domainSound = _groupLoadSwfSound.loader.contentLoaderInfo.applicationDomain;
                       
                        xmlData = XML(_groupLoadXmlData.data);
                       
                        removeGroupLoadDispatcher(_groupLoad);
                }
        }
}

var rss:XML;
var rssList:XMLList;
var contentEncodedString:String;

var loaderXML:URLLoader = new URLLoader();
loaderXML.addEventListener(Event.COMPLETE, loadXMLCompleteHandler);
loaderXML.load(new URLRequest(“rss.xml”));

function loadXMLCompleteHandler(evt:Event):void
{
        rss = new XML(evt.target.data);
        rssList = rss.channel.item[0].children();
        for(var i:uint=0; i<rssList.length(); i++)
        {
                if(rssList[i].name() == “description”)
                {
                        contentEncodedString = String(rssList[i+1].children()[0]);
                        trace(contentEncodedString);
                        break;
                }
        }
}

var scrollBar:MovieClip = scrollbar_mc;
var scrollBase:MovieClip = scrollBase_mc;
var scrollMask:MovieClip = scrollContentMask_mc;
var scrollContent:MovieClip = scrollContent_mc;

var scrollBarOriginX:Number = scrollBar.x;
var scrollBarOriginY:Number = scrollBar.y;
var scrollContentOriginY:Number = scrollContent.y;

var posY:Number;
var dragRectangle:Rectangle;
var nScrollContentHeight:Number = scrollContent.height;
var nMaskHeight:Number = scrollMask.height;
var nScrollBaseHeight:Number = scrollBase.height;
var nScrollBarHeight:Number;

if (nScrollContentHeight > nMaskHeight){
        scrollBar.visible = true;
        nScrollBarHeight = Math.floor(nScrollBaseHeight * nMaskHeight / nScrollContentHeight);
        scrollBar.height = nScrollBarHeight;
        scrollBar.buttonMode = true;
        scrollBar.addEventListener(MouseEvent.MOUSE_DOWN, scrollBarMouseDownHandler);
        scrollBase.addEventListener(MouseEvent.MOUSE_DOWN, scrollBaseMouseDownHandler);
        stage.addEventListener(Event.ENTER_FRAME, stageEnterFrameHandler);
}else{
        scrollBar.visible = false;
}

function scrollBarMouseDownHandler(evt:MouseEvent):void{
        dragRectangle = new Rectangle(scrollBarOriginX, scrollBarOriginY, 0, nScrollBaseHeight - nScrollBarHeight);
        evt.currentTarget.startDrag(false, dragRectangle);
        stage.addEventListener(MouseEvent.MOUSE_UP, stageMouseUpHandler);
}
function stageMouseUpHandler(evt:Event):void {
        scrollBar.stopDrag();
        stage.removeEventListener(MouseEvent.MOUSE_UP, stageMouseUpHandler);
}

function scrollBaseMouseDownHandler(evt:MouseEvent):void{
        if(scrollBar.y >= mouseY){
                if(scrollContent.y < scrollContentOriginY){
                        if (nMaskHeight >= -scrollContent.y){
                                posY = scrollContentOriginY;
                        }else{
                                posY = scrollContent.y + nMaskHeight;
                        }
                }
        }
        else if (nScrollContentHeight - nMaskHeight + (scrollContent.y - scrollContentOriginY) - nMaskHeight <= 0){
                posY = scrollContentOriginY - nScrollContentHeight + nMaskHeight;
        }else{
                posY = scrollContent.y - nMaskHeight;
        }
        scrollBar.y = Math.round((scrollContentOriginY - posY) / (nScrollContentHeight - nMaskHeight) * (nScrollBaseHeight - nScrollBarHeight) + scrollBarOriginY);
}

function stageEnterFrameHandler(evt:Event):void{
        posY = Math.round(scrollContentOriginY-(nScrollContentHeight - nMaskHeight) * (scrollBar.y - scrollBarOriginY) / (nScrollBaseHeight - nScrollBarHeight) );
        scrollContent.y += (posY - scrollContent.y) * .4;
}

var textline:String = ‘Just play. Have fun.’;
var textlineLength:uint = textline.length;
view_txt.text = textline;
view_txt.addEventListener(Event.ENTER_FRAME, typeWriter);
function typeWriter(evt:Event):void {
        if (textlineLength > -1) {
                textlineLength–;
                evt.currentTarget.text = textline.substring(0, textlineLength);
        } else {
                evt.currentTarget.removeEventListener(Event.ENTER_FRAME, typeWriter);
        }
}

package fr.manmaru.util
{

        /**
                Correct @ and . Symbol not showing in french and english input textfields
                when WMODE is set has transparent/opaque on FireFox web browser
                Windows OS only..
               
                @author Adrien Dufond
                @version 09/17/08
        */
       
        import flash.text.TextField;
        import flash.events.Event;
        import flash.events.KeyboardEvent;
        import flash.system.Capabilities;

        public class FirefoxWmodeFix
        {
               
                private static var usedKey:Array = new Array();
                private static var usedShiftKey:Boolean;
                private static var sLang:String;
                private static var sCurrentText:String;
               
                public static function firefoxWmodeFix(_field:TextField):void
                {
                        sLang = Capabilities.language.substr(0,2);
                        _field.addEventListener(Event.CHANGE, onFieldChangeHandler);
                        _field.addEventListener(KeyboardEvent.KEY_DOWN, onFieldKeyDownHandler);
                }
               
                private static function onFieldChangeHandler(evt:Event):void
                {
                        sCurrentText = evt.target.text;
                        if(sLang == ‘fr’)
                        {
                                if ((usedKey[usedKey.length-1] == “48″) && (usedKey[usedKey.length-2] == “18″) && (usedKey[usedKey.length-3] == “17″))
                                {
                                        evt.target.text = sCurrentText.substr(0, sCurrentText.length-1)+“@”;
                                }
                                if (usedShiftKey && (usedKey[usedKey.length-1] == “190″) )
                                {
                                        evt.target.text = sCurrentText.substr(0, sCurrentText.length-1)+“.”;
                                }
                        }
                        else
                        {
                                //-> http://bugs.adobe.com/jira/browse/FP-105
                                if(evt.target.text.slice(evt.target.text.length-1, evt.target.text.length) == “\”“)
                                {
                                        evt.target.text = evt.target.text.slice(0, evt.target.text.length-1)+“@”;
                                }
                        }
                }
               
                private static function onFieldKeyDownHandler(evt:KeyboardEvent):void
                {
                        usedKey.push(evt.keyCode);
                        usedShiftKey = evt.shiftKey;
                }
               
        }
}

var textline:String = “Just play. Have fun.”;
var intervalTimer:Timer = new Timer(500, 0);
intervalTimer.addEventListener(TimerEvent.TIMER, delay);
intervalTimer.start();

function delay(event:TimerEvent):void{
     var tmp:String = textline.substr(0, 1);
     textline = textline.substr(1, textline.length - 1) + tmp;
     view_txt.text = textline;
}

var textline:String = “Just play. Have fun.”;
view_txt.addEventListener(Event.ENTER_FRAME, typeWriter);
function typeWriter(evt:Event):void{
        if (evt.currentTarget.length != textline.length){
                evt.currentTarget.appendText(textline.charAt(evt.currentTarget.length));
        }else{
                evt.currentTarget.removeEventListener(Event.ENTER_FRAME, typeWriter);
        }
}