mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/nm/ui/ScrollText_base.as

@@ -0,0 +1,295 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui
+{
+	import flash.events.Event;
+	import flash.events.FocusEvent;
+	import flash.text.TextField;
+	import flash.text.TextFieldType;
+	import flash.text.TextFormat;
+	public class ScrollText_base extends Component
+	{
+		private var vScroll:ScrollBar;
+		public  var tf:TextField;
+		private var tf_format:TextFormat;
+		private var focused:Boolean;
+		private var lines:Number;
+		private var linesPerPage:Number;
+		private var updateTimeout:Number;
+		private var blocker:ContentBlocker;
+		private var __enabled:Boolean
+		private var _editable:Boolean;
+		private var _pendingText:String;
+		function ScrollText_base(width:Number, height:Number, text:String = '', textFormat:TextFormat = null)
+		{
+			super(true, width, height);
+			focused = false;
+			_enabled = true;
+			if(textFormat is TextFormat && textFormat != null) setStyle('textFormat', textFormat);
+			else setStyle("textFormat", new TextFormat());
+			addEventListener(FocusEvent.FOCUS_IN, onSetFocus);
+			addEventListener(FocusEvent.FOCUS_OUT, onKillFocus);
+			tf = new TextField();
+			tf.useRichTextClipboard = true;
+			tf.background = true;
+			tf.border = true;
+			editable = true;
+			setText(text);
+			tf.addEventListener(Event.SCROLL, onSelectionScroll);
+		}
+		public override function draw():void
+		{
+			super.draw();
+			addChild(tf);
+			redraw();
+			//Set textfield text if there is text waiting to be added
+			if(_pendingText) setText(_pendingText);
+		}
+		protected override function styleDefaults():void
+		{
+			setStyle('bgColor', 0xFFFFFF)
+			setStyle('frameW', 1);
+			setStyle('embedFonts', false);
+			setStyle('textFormat', new TextFormat('Arial', 12, 0 ));
+			setStyle('showBorder', true);
+		}
+		public override function redraw():void
+		{
+			tf.embedFonts = getStyle('embedFonts')
+			//////trace('embed ' + tf.embedFonts)
+			textFormat = getStyle('textFormat')
+			tf.wordWrap = true;
+			tf.multiline = true;
+			drawBG();
+			sizeTextField();
+			positionScroll(); //+ZACH
+			super.redraw();
+		}
+		protected function drawBG():void{}
+		private function sizeTextField():void
+		{
+			var calcWidth:Number = width;
+			if(vScroll != null) calcWidth -= vScroll.width;
+			tf.width = calcWidth;
+			tf.height = height;
+		}
+		private function showScroll():void
+		{
+			if(vScroll == null)
+			{
+				var lineHeight:int = tf.getLineMetrics(0).height;
+				var frameW:Number = getStyle('frameW');
+				vScroll = new ScrollBar();
+				addChild(vScroll);
+				vScroll.totalLines = tf.textHeight/lineHeight; //tf.maxScrollV;
+				vScroll.linesPerPage = tf.height/lineHeight;
+				vScroll.scrollByLines = 3;
+				vScroll.addEventListener('scroll', onScroll);
+				vScroll.addEventListener('drag', drag);
+				positionScroll();
+				sizeTextField();
+			}
+		}
+		private function positionScroll():void
+		{
+			var frameW:Number = getStyle('frameW');
+			if(vScroll != null) vScroll.x = width-vScroll.width
+		}
+		private function hideScroll():void
+		{
+			if(vScroll == null) return;
+			removeChild(vScroll); vScroll = null;
+			sizeTextField();
+		}
+		public function get isScrollActive():Boolean
+		{
+			return vScroll is ScrollBar;
+		}
+		private function update(timeOut:Boolean=false):void
+		{
+			if(timeOut)
+			{
+				if(tf.maxScrollV > 1)
+				{
+					if(vScroll == null) showScroll();
+					if(vScroll.totalLines != tf.maxScrollV)	vScroll.totalLines = tf.maxScrollV;
+				}
+				else
+				{
+					hideScroll();
+				}
+			}
+			//vScroll.removeEventListener('scroll', this); // mute for now
+			if(vScroll != null) vScroll.scroll = ((tf.scrollV-1)/(tf.maxScrollV-1))*100;
+			//vScroll.addEventListener('scroll', this); // ok, listen again
+		}
+		
+		public function checkScrollability():void
+		{
+			tf.getCharBoundaries(0);
+			if (tf.maxScrollV > 1)
+			{
+				showScroll();
+				return;
+			}
+			hideScroll();
+			return;
+		}
+		
+		//********   textfield listener functions ************//
+		private function onScroller():void
+		{
+			update();
+			///*_global.*/clearTimeout(updateTimeout);
+			//updateTimeout = /*_global.*/setTimeout(this, 'update', 100, true); // do this to overcome a bug that happens during fast scrolling where textfield doesnt fire this event again
+		}
+		private function updateTimer(e:Event):void
+		{
+		}
+		public function onChanged():void
+		{
+			dispatchEvent(new Event('change'));//dispatchEvent({type:'change', target:this})
+		}
+		private function onSetFocus(e:Object):void
+		{
+			dispatchEvent(new Event('setFocus')); //dispatchEvent( { type:'setFocus', target:this } )
+		}
+		private function onKillFocus(e:Object):void
+		{
+			dispatchEvent(new Event('killFocus'));//dispatchEvent({type:'killFocus', target:this})
+		}
+		private function setText(text:String = ""):void
+		{
+			if(stage)
+			{
+				tf.text = text;
+				tf.getCharBoundaries(0); // this will update maxScrollV to the correct v alue
+				//tf.height;
+				//tf.textHeight;
+				if(tf.maxScrollV > 1) showScroll();
+				else hideScroll();
+			}
+			else
+			{
+				_pendingText = text;
+			}
+		}
+		private function drag(eObj:Object):void
+		{
+			if(eObj.result)
+			{
+				//tf.removeListener(this) // mute for now
+			}
+			else
+			{
+				//tf.addListener(this) // mute for now
+			}
+		}
+		private function onScroll(eObj:Object):void
+		{
+			var s:Number = Math.floor(eObj.result/100 * (tf.maxScrollV))+1
+			if(tf.scrollV != s) tf.scrollV = s
+		}
+		public function onSelectionScroll(e:Event):void
+		{
+			update();
+		}
+		public function set _enabled(val:Boolean):void
+		{
+			__enabled = val;
+			if (val == true && blocker != null) removeChild(blocker);
+			else
+			{
+				if(blocker == null) blocker = new ContentBlocker(width, height, 0xFFFFFF, 65);
+				else
+				{
+					blocker.height = height
+					blocker.width = width
+				}
+			}
+		}
+		public function get _enabled():Boolean
+		{
+			return __enabled;
+		}
+		public function get scroll():Number
+		{
+			if(!vScroll)
+			{
+				return 0;
+			}
+			
+			return vScroll.scroll
+		}
+		public function set scroll(val:Number):void
+		{
+			if(vScroll)
+			{
+				vScroll.scroll = val;
+			}
+		}
+		public override function set height(val:Number):void
+		{
+			super.height = val;
+			if(vScroll != null) vScroll.redraw();
+		}
+		public function set text(text:String):void
+		{
+			setText(text)
+		}
+		public function get text():String
+		{
+			return tf.text;
+		}
+		public function set htmlText(text:String):void
+		{
+			tf.htmlText = text;
+			tf.scrollV = 0
+//			trace('tf.maxScrollV', tf.maxScrollV)
+			if(tf.maxScrollV > 1) showScroll();
+		}
+		public function get htmlText():String
+		{
+			return tf.htmlText;
+		}
+		public function set selectable(select:Boolean):void
+		{ // <-- KEEGAN
+			tf.selectable = select;
+		}
+		public function get selectable():Boolean
+		{
+			return tf.selectable;
+		}
+		public function get textFormat():TextFormat
+		{
+			return tf.getTextFormat();
+		}
+		public function set textFormat(tf_format:TextFormat):void
+		{
+			this.tf_format = tf_format
+			tf.setTextFormat(tf_format)
+			tf.defaultTextFormat = tf_format;
+			//tf.setTextFormat(tf_format)
+		}
+		public function set editable(val:Boolean):void
+		{
+			_editable = val
+			tf.type = (val? TextFieldType.INPUT : TextFieldType.DYNAMIC)
+		}
+		public function get editable():Boolean
+		{
+			return _editable
+		}
+		public function get isSelectable():Boolean
+		{
+			return tf.embedFonts;
+		}
+		public function get embedFonts():Boolean
+		{
+			return tf.embedFonts;
+		}
+		public function set embedFonts(tf_embed:Boolean):void
+		{
+			setStyle('embedFonts', tf_embed);
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/nm/ui/SimpleScrollBar.as

@@ -0,0 +1,247 @@
+package nm.ui
+{
+	import flash.display.DisplayObject;
+	import flash.display.Sprite;
+	import flash.events.Event;
+	import flash.events.MouseEvent;
+	import flash.geom.Matrix;
+	import flash.geom.Rectangle;
+	import flash.geom.Transform;
+	import flash.text.TextField;
+	public class SimpleScrollBar extends Sprite
+	{
+		private var _linkedTF:TextField;
+		private var _track:Sprite
+		private var _thumb:Sprite
+		private var _minThumbHeight:Number = 50
+		private var _lastMouseY:Number
+		private var _isDragging:Boolean = false
+		private var _linkedSprite:Sprite;
+		public var clickJumpSize:uint = 15
+		private var _padding:uint
+		private var _color:int
+		/**
+		 * Creates a simple Scroll bar that is the same height as the linked item.  You must manually place the scrollbar after creating it.
+		 * @param linkedItem	Either a textfield or a Sprite using scrollrect for vertical scrolling
+		 * @param padding		Padding in pixels added to top and bottom of the scroll bar.
+		 *
+		 */
+		public function SimpleScrollBar(linkedItem:DisplayObject, padding:uint=10, color:int=0x000000)
+		{
+			super();
+			_padding = padding
+			_color = color
+			if(linkedItem is TextField)
+			{
+				_linkedTF = linkedItem as TextField
+				_linkedTF.addEventListener(Event.SCROLL, onTFScroll, false, 0, true)
+				_linkedTF.addEventListener(Event.CHANGE, onTFChange, false, 0, true)
+			}
+			else if(linkedItem is Sprite)
+			{
+				_linkedSprite = linkedItem as Sprite
+				_linkedSprite.addEventListener(MouseEvent.MOUSE_WHEEL, onSpriteScrollWheel, false, 0, true)
+			}
+			addEventListener(MouseEvent.CLICK, onClick, false, 0, true)
+			addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown, false, 0, true)
+			_track = new Sprite()
+			_thumb = new Sprite()
+			addChild(_track)
+			addChild(_thumb)
+			alpha = .4
+			draw()
+		}
+		/**
+		 * onChange handler for textfields
+		 *
+		 * @param e
+		 *
+		 */
+		private function onTFChange(e:Event):void
+		{
+			draw();
+		}
+		/**
+		 * onScroll Handler for textfields
+		 *
+		 * @param e
+		 *
+		 */
+		private function onTFScroll(e:* = null):void
+		{
+			if(!_isDragging)
+			{
+				_thumb.y =   (_linkedTF.scrollV-1)/(_linkedTF.maxScrollV-1) * (_track.height - _thumb.height ) //+ _padding
+			}
+		}
+		/**
+		 *
+		 *
+		 */
+		private function onSpriteScroll():void
+		{
+			if(!_isDragging)
+			{
+				var trackHeight:Number = _linkedSprite.scrollRect.height - _padding * 2
+				var bounds:Rectangle = getBoundsWithoutScrollRect(_linkedSprite)
+				_thumb.y =   (_linkedSprite.scrollRect.y) / (bounds.height - _linkedSprite.scrollRect.height) * (trackHeight - _thumb.height )
+			}
+		}
+		protected function onSpriteScrollWheel(event:MouseEvent):void
+		{
+			_thumb.y -= ( event.delta)
+			// keep the thumb inside the bounds
+			if(_thumb.y < 0) _thumb.y = 0
+			else if(_thumb.y + _thumb.height > _track.height) _thumb.y = _track.height - _thumb.height
+			// update the container
+			if(_linkedSprite) updateSpriteScrollPosition();
+		}
+		private function updateTFScroll():void
+		{
+			_linkedTF.scrollV = ((_thumb.y / (_track.height - _thumb.height )) * (_linkedTF.maxScrollV-1))+1
+		}
+		private function updateSpriteScrollPosition():void
+		{
+			var bounds:Rectangle = getBoundsWithoutScrollRect(_linkedSprite)
+			var sRect:Rectangle = _linkedSprite.scrollRect
+			sRect.y = (_thumb.y / (_track.height - _thumb.height )) * (bounds.height - sRect.height)
+			_linkedSprite.scrollRect = sRect
+		}
+		/**
+		 * This function works like DisplayObject.getBounds(), except it will find the
+		 * bounds of any display object, even after its scrollRect has been set.
+		 *
+		 * @param displayObject - a display object that may have a scrollRect applied
+		 * @return a rectangle describing the dimensions of the unmasked content
+		 */
+		private function getBoundsWithoutScrollRect ( displayObject:DisplayObject ) :Rectangle
+		{
+			var bounds:Rectangle
+			var transform:Transform
+			var toGlobalMatrix:Matrix
+			var currentMatrix:Matrix;
+			transform = displayObject.transform;
+			currentMatrix = transform.matrix;
+			toGlobalMatrix = transform.concatenatedMatrix;
+			toGlobalMatrix.invert();
+			transform.matrix = toGlobalMatrix;
+			bounds = transform.pixelBounds.clone();
+			transform.matrix = currentMatrix;
+			return bounds;
+		}
+		/**
+		 * Event Handler for mouse button down
+		 * @param e
+		 *
+		 */
+		private function onMouseDown(e:MouseEvent):void
+		{
+			e.stopPropagation()
+			_lastMouseY = mouseY
+			_isDragging = true
+			stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove, false, 0, true)
+			stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp, false, 0, true)
+		}
+		/**
+		 * Event Handler for mouse movement while dragging the scroll thumb
+		 *
+		 * @param e
+		 *
+		 */
+		private function onMouseMove(e:MouseEvent):void
+		{
+			_thumb.y += ( mouseY - _lastMouseY)
+			_lastMouseY = mouseY
+			// keep the thumb inside the bounds
+			if(_thumb.y < 0) _thumb.y = 0
+			else if(_thumb.y + _thumb.height > _track.height) _thumb.y = _track.height - _thumb.height
+			// update the container
+			if(_linkedTF) updateTFScroll()
+			if(_linkedSprite) updateSpriteScrollPosition();
+		}
+		private function onMouseUp(e:MouseEvent):void
+		{
+			_isDragging = false
+			stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove)
+			stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp)
+		}
+		private function onClick(e:MouseEvent):void
+		{
+			if(e.target == _track)
+			{
+				if(_linkedTF)
+				{
+					if(e.localY < _thumb.y) _linkedTF.scrollV--
+					else _linkedTF.scrollV++
+				}
+				if(_linkedSprite)
+				{
+					var trackHeight:Number = _linkedSprite.scrollRect.height - _padding * 2
+					var sRect:Rectangle = _linkedSprite.scrollRect
+					var bounds:Rectangle = getBoundsWithoutScrollRect(_linkedSprite)
+					if(e.localY < _thumb.y + _padding) sRect.y -= clickJumpSize
+					else sRect.y += clickJumpSize
+					// keep in bounds
+					if(sRect.y < 0 ) sRect.y = 0
+					else if(sRect.y > bounds.height - _linkedSprite.height) sRect.y = bounds.height - _linkedSprite.height
+					_linkedSprite.scrollRect = sRect
+					onSpriteScroll()
+				}
+			}
+		}
+		public function draw():void
+		{
+			var thumbHeight:Number
+			var trackHeight:Number
+			_track.graphics.clear()
+			_thumb.graphics.clear()
+			// Textfields
+			if(_linkedTF)
+			{
+				trackHeight = _linkedTF.height - _padding * 2
+				thumbHeight = (trackHeight/_linkedTF.textHeight) * trackHeight
+				thumbHeight = thumbHeight > _minThumbHeight ? thumbHeight : _minThumbHeight
+				// Draw if needed
+				if(thumbHeight < trackHeight)
+				{
+					_track.graphics.beginFill(_color, 1)
+					_track.graphics.drawRoundRect(0, _padding, 6, trackHeight, 5, 8)
+					_track.graphics.endFill()
+					_thumb.graphics.beginFill(_color, .65)
+					_thumb.graphics.drawRoundRect(0, _padding, 6, thumbHeight , 5, 8)
+					_thumb.graphics.endFill()
+					onTFScroll()
+				}
+			}
+			// ScrollRect Sprites
+			else if(_linkedSprite && _linkedSprite.scrollRect)
+			{
+				trackHeight = _linkedSprite.scrollRect.height - _padding * 2
+				thumbHeight = (trackHeight/_linkedSprite.height) * trackHeight
+				thumbHeight = thumbHeight > _minThumbHeight ? thumbHeight : _minThumbHeight
+				// Draw if needed
+				if(thumbHeight < _linkedSprite.height)
+				{
+					_track.graphics.beginFill(_color, .5)
+					_track.graphics.drawRoundRect(0, _padding, 6, trackHeight, 5, 8)
+					_track.graphics.endFill()
+					_thumb.graphics.beginFill(_color, 1)
+					_thumb.graphics.drawRoundRect(0, _padding, 6, thumbHeight , 5, 8)
+					_thumb.graphics.endFill()
+				}
+			}
+		}
+		public function shutdown():void
+		{
+			if(_linkedTF)
+			{
+				_linkedTF.removeEventListener(Event.SCROLL, onTFScroll)
+				_linkedTF.removeEventListener(Event.CHANGE, onTFChange)
+			}
+			removeEventListener(MouseEvent.CLICK, onClick)
+			removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown)
+			_linkedTF = null
+			_linkedSprite = null
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/nm/ui/StageRef.as

@@ -0,0 +1,34 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui
+{
+	import flash.display.MovieClip;
+	import flash.display.Stage;
+	public class StageRef extends MovieClip
+	{
+		private var _stageRef:Stage;
+		private static var _instance:StageRef;
+		private static var _allowInstantiation:Boolean;
+		public static function getInstance():StageRef {
+			if(_instance == null) {
+				_allowInstantiation = true;
+				_instance = new StageRef();
+				_allowInstantiation = false;
+			}
+			return _instance;
+		}
+		public static function init(stageRef:Stage):void {
+			getInstance()._stageRef = stageRef;
+		}
+		public function StageRef():void {
+			if(!_allowInstantiation) {
+				throw new Error("Error: instantiation failed, use StageRef.getInstance() instead of new");
+			}
+		}
+		public static function stageWidth():Number {
+			return getInstance()._stageRef.stageWidth;
+		}
+		public static function stageHeight():Number {
+			return getInstance()._stageRef.stageHeight;
+		}
+	}
+}