<?xml version="1.0" encoding="utf-8"?>
<mx:Canvas xmlns:mx="http://www.adobe.com/2006/mxml">
 
	<mx:Metadata>
		[Event(name="ad_completed", type="flash.events.Event")]
		[Event(name="ad_absent", type="flash.events.Event")]
		[Event(name="ad_error", type="flash.events.Event")]
	</mx:Metadata>
	<mx:Script>
		<![CDATA[
			import mx.controls.SWFLoader;
			import mx.core.FlexMovieClip;
 
			// Possible ad types
			public static const BEFORE_CONTENT:String 		= "before_content";
			public static const DURING_CONTENT:String 		= "during_content";
			public static const AFTER_CONTENT:String		= "after_content";
 
			/**
			 * URL to where you are hosting "yume_player_4x3.swf"
			 */
			public static var yume_player_swf_url:String 	= "yume_player_4x3.swf";
 
			/**
			 * URL to where you are hosting "yume_ad_library.swf"
			 */
			public static var yume_library_swf_url:String	= "yume_ad_library.swf";
 
			/**
			 * URL to where you are hosting any specific CSS associated with the YuMe ads you are displaying.
			 */
			public var yume_css_url:String 					= "";
 
			public var ad_width:Number 	= 480;
			public var ad_height:Number = 360;
 
			/**
			 * The type of ad to play in this player the next time startAd() is called,
			 * valid values are: "before_content", "during_content", "after_content"
			 */
			public function set ad_type( value:String ):void {
				// set ad type
				yume_params.ad_type = value;
				regeneratePlaylistURL();
			}
 
			/**
			 * Help YuMe target the video ad by passing tags related to the content this ad will be shown with.
			 */
			public function set tags( value:String ):void {
				_tags = value;
				regeneratePlaylistURL();
			}
 
			/**
			 * Help YuMe target the video ad by passing the title of the content this ad will be shown with.
			 */
			public function set title( value:String ):void {
				_title = value;
				regeneratePlaylistURL();
			}
 
			/**
			 * Help YuMe target the video ad by passing the duration of the content this ad will be shown with.
			 */
			public function set duration( value:Number ):void {
				_duration = value;
				regeneratePlaylistURL();
			}
 
			/**
			 * Help YuMe advertisers target your company's content by giving them a way to identify you.
			 */
			public function set channel( value:String ):void {
				_channel = value;
				regeneratePlaylistURL();
			}
 
			/**
			 * Any YuMe specific errors caught by the YuMe player.
			 * You should check this value if you catch an "ad_error" event.
			 */
			public function get errors():String {
				return _yume ? _yume.error_string : null;
			}
 
			/**
			 * The object the YuMe interface will be loaded into and accessible through.
			 */
			private var _yume:Object;
 
			/**
			 * The actual visual component the YuMe video will be loaded into.
			 */
			private var _yume_mc:MovieClip = new MovieClip();
 
			/**
			 * True if the yume swfs have been successfully loaded and initialized, false otherwise.
			 */
			private var _yume_ready:Boolean = false;
 
			/**
			 * True if there has been a request to play a YuMe ad. This allows the containing application
			 * to initialize and immediately request ad playback without having to worry about asynchronous
			 * load times and have the ad begin playing as soon as it's loaded. 
			 */
			private var _start_requested:Boolean = false;
 
			/**
			 * Your YuMe API key, given to you by YuMe when you're approved. Below is the test key.
			 */
			private var _yume_api_key:String = "88ElOFHxAh";
 
			/**
			 * Any tags associated with the current content being monetized.
			 */
			private var _tags:String = "";
 
			/**
			 * The title of the current content being monetized.
			 */
			private var _title:String = "";
 
			/**
			 * The duration of the current content being monetized.
			 */
			private var _duration:Number = 30;
 
			/**
			 * The name of the YuMe channel you want to create for advertisers to target.
			 */
			private var _channel:String = "your-company";
 
			public var yume_params:Object = {
				parent_mc: 				_yume_mc,
				ad_type: 				BEFORE_CONTENT,
				yume_url:				yume_player_swf_url,
				yume_library_swf_url:	yume_library_swf_url,
				// this is the test playlist from the YuMe setup documentation
				playlist:				"http://shadow01.yumenetworks.com/dynamic_preroll_playlist.fmil?domain=88ElOFHxAh",
				update_interval: 		1000,
				ad_volume:				100,
				normalscreen_x:			0,
				normalscreen_y:			0,
				normalscreen_width:		ad_width,
				normalscreen_height:	ad_height,
				fullscreen_x:			0,
				fullscreen_y:			0,
				fullscreen_width:		ad_width,
				fullscreen_height:		ad_height,
				yume_leader_slot:		true,
				css_url:				yume_css_url
			};
 
			private function regeneratePlaylistURL():void {
				// set playlist url
				var playlist_type:String = "";
				if( yume_params.ad_type == "during_content" ){
					playlist_type = "dynamic_midroll_playlist.fmil";
				}else if( yume_params.ad_type == "after_content" ){
					playlist_type = "dynamic_postroll_playlist.fmil";
				}else{
					playlist_type = "dynamic_preroll_playlist.fmil";	
				}
				yume_params.playlist = "http://shadow01.yumenetworks.com/" + playlist_type 
					+ "?channel=" + encodeURIComponent( _channel )
                                        + "&domain=" + _yume_api_key 
					+ "&title=" + encodeURIComponent( _title ) 
					+ "&tags=" + encodeURIComponent( _tags ) 
					+ "&duration=" + _duration;	
			}
 
			private function init():void {
				Security.allowDomain( "*" );
				Security.allowInsecureDomain( "*" );
				yume_holder.addChild( _yume_mc );
				var loader:SWFLoader = new SWFLoader();
				loader.addEventListener( Event.COMPLETE, handleLoaderComplete );
				loader.load( yume_library_swf_url );
			}
 
			private function handleLoaderComplete( e:Event ):void {
				_yume 			= e.target.content.yume_ad;
				setupListeners( _yume as IEventDispatcher );
				_yume_ready = true;
				if( _start_requested ){
					startAd();
				}
			}
 
			public function startAd():void {
				if( _yume_ready ){
					yume_params.normalscreen_width 	= this.width;
					yume_params.normalscreen_height 	= this.height;
					_yume.start_ad( yume_params );
					_start_requested = false;
				}else{
					_start_requested = true;
				}
			}
 
			// ================= YUME AD LISTENER IMPLEMENTATION ==============
			private function setupListeners( target:IEventDispatcher ):void {
				target.addEventListener( "ad_present", ad_present );
				target.addEventListener( "ad_absent", ad_absent );
				target.addEventListener( "ad_playing", ad_playing );
				target.addEventListener( "ad_completed", ad_completed );
				target.addEventListener( "ad_closed", ad_closed );
				target.addEventListener( "image_closed", image_closed );
				target.addEventListener( "ad_reopened", ad_reopened );
				target.addEventListener( "ad_clicked2site", ad_clicked2site );
				target.addEventListener( "ad_clicked2video", ad_clicked2video );
				target.addEventListener( "pip_video_playing", pip_video_playing );
				target.addEventListener( "pip_video_completed", pip_video_completed ); 
				target.addEventListener( "ad_error", ad_error );
			}
 
			private function ad_absent( e:Event ):void {
				// bubble
				dispatchEvent( e );
			}
 
			private function ad_error( e:Event ):void {
				// bubble
				dispatchEvent( e );
			}
 
			private function ad_completed( e:Event ):void {
				// bubble
				dispatchEvent( e );
			}
 
			private function ad_playing( e:Event ):void {
				trace( e );
				// displays the number of seconds left in the ad for the user if it can be determined
				if( _yume.get_duration() > 0 ){
					var seconds_left:int = Math.round( _yume.get_duration() - _yume.get_time() );
					info.text = "Sponsor: " + ( seconds_left >= 0 ? seconds_left : '' ) 
						+ " second" + ( seconds_left != 1 ? 's' : '' ) + " remaining";
				}
			}
 
			private function ad_present( e:Event ):void {
				trace( e );
			}
 
			private function image_closed( e:Event ):void {
				trace( e );
			}
 
			private function ad_closed( e:Event ):void {
				trace( e );
			}
 
			private function ad_reopened( e:Event ):void {
				trace( e );
			}
 
			private function ad_clicked2site( e:Event ):void {
				trace( e );
			}
 
			private function ad_clicked2video( e:Event ):void {
				trace( e );
			}
 
			private function pip_video_playing( e:Event ):void {
				trace( e );
			}
 
			private function pip_video_completed( e:Event ):void {
				trace( e );
			}		
 
		]]>
	</mx:Script>
 
	<!-- just a holder for the video ad -->
	<mx:UIComponent id="yume_holder" width="100%" height="100%" creationComplete="init()"/>
 
	<!-- displays the seconds countdown -->
	<mx:HBox backgroundColor="#323232" backgroundAlpha="0.5" width="100%" top="0" paddingLeft="10">
		<mx:Label id="info" fontSize="10" color="#FFFFFF"/>
	</mx:HBox>
 
</mx:Canvas>

package components
{
	import flash.display.Bitmap;
	import flash.display.Loader;
	import flash.events.Event;
	import flash.system.LoaderContext;
 
	import mx.controls.Image;
	import mx.core.mx_internal;
 
        use namespace mx_internal;
 
	public class PolicyCheckingImage extends Image
	{
		public function PolicyCheckingImage()
		{
			super();
			this.loaderContext = new LoaderContext( true );
		}
 
	/**
         * @private
         */
        override mx_internal function contentLoaderInfo_completeEventHandler(event:Event):void {
            var smoothLoader:Loader = event.target.loader as Loader;
            var smoothImage:Bitmap = smoothLoader.content as Bitmap;
            smoothImage.smoothing = true;
 
            super.contentLoaderInfo_completeEventHandler(event);
        }
 
 
	}
}

package {
 
	import flash.errors.IllegalOperationError;
	import flash.events.Event;
	import flash.events.HTTPStatusEvent;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.net.navigateToURL;
	import flash.external.ExternalInterface;
 
	public class Share { 
 
		public static const BITLY_USERNAME:String 	= "";
		public static const BITLY_API_KEY:String	= "";
 
		public var title:String 		= "";
		public var description:String 	= "";
		public var tweet_text:String	= "";
 
		public var bitlyURL:String;
 
		private var _window_location:String;
 
 
		/**
		 * The Singleton instance of the ShareManager to use when accessing properties and methods of the ShareManager.
		 */		
		public static const instance:Share = new Share( ShareSingletonLock );
 
		public function Share( lock:Class ){
			if( lock != ShareSingletonLock ){
				throw new IllegalOperationError( "ShareManager is a Singleton, please use the static instance method instead." );
			}else{
				_window_location = ExternalInterface.call( "function () { return window.location.href.toString().toLowerCase(); }" );
				if( _window_location != "" ){
					try{
						getBitlyURL();
					}catch( e:Error ){
						trace( "ShareManager::Constructor > error getting bitly url: " + getBitlyURL() );
					}
				}
			}
		}
 
		public function init( title:String, description:String, tweet_text:String ):void {
			this.title			= title;
			this.description	= description;
			this.tweet_text		= tweet_text;
		}
 
		private function getBitlyURL():void {
			var bitly_api:String	= "http://api.bit.ly/shorten?version=2.0.1&longUrl=";
			bitly_api 				+= encodeURIComponent( _window_location );
			bitly_api 				+= "&login=" + BITLY_USERNAME;
			bitly_api 				+= "&apiKey=" + BITLY_API_KEY;
 
			var loader:URLLoader = new URLLoader();
			loader.addEventListener( Event.COMPLETE, handleBitlyComplete );
			loader.addEventListener( HTTPStatusEvent.HTTP_STATUS, handleBitlyStatus );
			loader.addEventListener( IOErrorEvent.IO_ERROR, handleBitlyError );
			loader.addEventListener( SecurityErrorEvent.SECURITY_ERROR, handleBitlyError );
			loader.load( new URLRequest( bitly_api ) );
		}
 
		private function handleBitlyComplete( e:Event ):void {
			trace( 'BITLY url load complete: ' + e );
			var loader:URLLoader = e.target as URLLoader;
			try{
				var response:Object = ExternalInterface.call("function(){return " + ( loader.data as String ) + "}");
				if( response.statusCode == "OK" && response.results[ _window_location ] != null && response.results[ _window_location ].errorCode == null ){
					bitlyURL = response.results[ _window_location].shortUrl;
					trace( 'Set BITLY url to: ' + bitlyURL );
				}
			}catch( e:Error ){
				trace( "Error decoding BITLY response (" + loader.data + "): " + e );
			}
		}
 
		private function handleBitlyStatus( e:HTTPStatusEvent ):void {
			trace( 'BITLY status: ' + e );	
		}
 
		private function handleBitlyError( e:Event ):void {
			trace( 'Getting BITLY url failed with error: ' + e );
		}
 
		public function get redditURL():String {
			return 'http://www.reddit.com/submit?url=' + encodeURIComponent( _window_location ) + "&title=" + encodeURIComponent( title );
		}
 
		public function openReddit():void {
			navigateToURL( new URLRequest( redditURL ), '_blank' );
		}
 
		public function get diggURL():String {
			var url:String = "http://digg.com/submit?url=" + encodeURIComponent( _window_location );
			url += "&title="    + encodeURIComponent( title );
			url += "&bodytext=" + encodeURIComponent( description );
			url += "&media=video";
			return url;
		}
 
		public function openDigg():void {
			navigateToURL( new URLRequest( diggURL ), '_blank' );
		}
 
		public function get twitterURL():String {
			var url_for_tweet:String  	= bitlyURL ? bitlyURL : _window_location;
			var twitter_status:String 	= encodeURIComponent( tweet_text );
			return "http://twitter.com/home/?status=" + twitter_status;
		}
 
		public function openTwitter():void {
			navigateToURL( new URLRequest( twitterURL ), '_blank' );
		}
 
		public function get mySpaceURL():String {
			var url:String = "http://www.myspace.com/index.cfm?fuseaction=postto";
			url += "&t=" + encodeURIComponent( title );
			url += "&c=" + encodeURIComponent( description );
			url += "&u=" + encodeURIComponent( _window_location );
			url += "&r=close";
			return url;
		}
 
		public function openMySpace():void {
			navigateToURL( new URLRequest( mySpaceURL ), '_blank' );
		}
 
		public function get facebookURL():String {
			var url:String = "http://www.facebook.com/share.php?src=bm&v=4&i=1254383639";
			url += "&u=" + encodeURIComponent( _window_location );
			url += "&t=" + encodeURIComponent( title );
			return url;
		}
 
		public function openFacebook():void {
			navigateToURL( new URLRequest( facebookURL ), '_blank' );
		}
 
	}
}
 
class ShareSingletonLock {}

package components.supportClasses {
 
	import flash.events.MouseEvent;
 
	import spark.components.supportClasses.ItemRenderer;
 
	public class NonDeselectingItemRenderer extends ItemRenderer {
		public function NonDeselectingItemRenderer()
		{
			super();
		}
 
		override protected function itemRenderer_rollOutHandler(event:MouseEvent):void {
			if( super.currentState != "selected" ){
				super.itemRenderer_rollOutHandler( event );
			}
		}
	}
}

package {
 
	import flash.events.KeyboardEvent;
 
	import spark.components.List;
 
	public class KeyShortcutsToggleList extends List {
 
		public var allowKeyboardNavigation:Boolean = false;
 
		override protected function keyDownHandler(event:KeyboardEvent) : void {
			if( allowKeyboardNavigation ){
				super.keyDownHandler( event );
			}
		}
 
		override protected function keyUpHandler(event:KeyboardEvent) : void {
			if( allowKeyboardNavigation ){
				super.keyUpHandler( event );
			}
		}
	}
}

<?xml version="1.0" encoding="utf-8"?>
<s:Label xmlns:fx="http://ns.adobe.com/mxml/2009" 
		 xmlns:s="library://ns.adobe.com/flex/spark" 
		 xmlns:mx="library://ns.adobe.com/flex/halo"
		 fontSize="14"
		 fontWeight="bold"
		 right="0" bottom="0"
		 addedToStage="reset()">
 
	<fx:Script>
		<![CDATA[
			import spark.components.supportClasses.SkinnableTextBase;
 
			/**
			 * If true, the CharacterCountDown will look something like "123".
			 * If false, the CharacterCountDown will look something like "123 characters left".
			 * 
			 * @default true
			 */
			public var onlyNumbers:Boolean = true;
 
			[Bindable] private var _target:SkinnableTextBase;
 
			/**
			 * Set the component that this CharacterCountDown instance will watch.
			 */
			public function set target( value:SkinnableTextBase ):void {
				_target = value;
				if( _target != null ){
					_target.addEventListener( KeyboardEvent.KEY_UP, handleKeyUp );
				}
			}
 
			public function get target():SkinnableTextBase {
				return _target;
			}
 
			public function reset():void {
				this.text = "";
			}
 
			private function handleKeyUp( e:KeyboardEvent ):void {
				var characters_left:int = (target.maxChars - target.text.length);
				this.text = String( characters_left );
				if( !onlyNumbers ){
					this.text += " character" + ( characters_left != 1 ? 's' : '' ) + " left"; 
				}
			}
 
			/**
			 * Causes the CharacterCountDown to stop watching any previously assigned target. 
			 */
			public function dispose():void {
				if( _target != null ){
					_target.removeEventListener( KeyboardEvent.KEY_UP, handleKeyUp );
					_target = null;
				}
			}
 
		]]>
	</fx:Script>
</s:Label>

package events {
 
	import flash.events.Event;
 
	public class _Event extends Event {
 
		public var data:*;
 
		public function _Event(type:String="", someData:*=null, bubbles:Boolean=true, cancelable:Boolean=false)
		{
			super(type, bubbles, cancelable);
			this.data = someData;
		}
 
		override public function clone() : Event
		{
			return new _Event(type, data, bubbles, cancelable);
		}
	}
}

package utils {
	import flash.display.GradientType;
	import flash.display.Graphics;
	import flash.display.SpreadMethod;
	import flash.geom.Matrix;
 
	import mx.utils.GraphicsUtil;
 
	public class GraphicsUtil extends mx.utils.GraphicsUtil
	{
		public static function drawGradientBackground( graphics:Graphics, colors:Array, width:Number, height:Number, fillType:String, cornerRadius:uint ):void {
			graphics.clear();
			var alphas:Array = [1, 1];
			var ratios:Array = [0x11, 0xFF];
			var matrix:Matrix = new Matrix();
			matrix.createGradientBox( width, height, Math.PI / 2, 0, 0);
			var spreadMethod:String = SpreadMethod.PAD;
			graphics.beginGradientFill(fillType, colors, alphas, ratios, matrix, spreadMethod);  
			graphics.drawRoundRect( 0, 0, width, height, cornerRadius, cornerRadius );
		}
 
		public static function drawLinearGradientBackground( graphics:Graphics, colors:Array, width:Number, height:Number, cornerRadius:uint ):void {
			drawGradientBackground( graphics, colors, width, height, GradientType.LINEAR, cornerRadius );
		}
 
		public static function drawRadialGradientBackground( graphics:Graphics, colors:Array, width:Number, height:Number, cornerRadius:uint ):void {
			drawGradientBackground( graphics, colors, width, height, GradientType.RADIAL, cornerRadius );
		}
	}
}

override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void {
     super.updateDisplayList( unscaledWidth, unscaledHeight );
     // draw a gradient background in the video screen
     GraphicsUtil.drawLinearGradientBackground( this.graphics, [0x101010,0x000000], unscaledWidth, unscaledHeight, this.getStyle("cornerRadius") );
}