The web page of Dan http://www.thewebpageofdan.com Tue, 25 Nov 2008 20:36:57 +0000 http://wordpress.org/?v=2.8.2 en hourly 1 Flash text fields have extra newlines/carriage returns (”\n” and “\r”) http://www.thewebpageofdan.com/2008/11/25/actionscript-text-fields-have-extra-newlinescarriage-returns-n-and-r/ http://www.thewebpageofdan.com/2008/11/25/actionscript-text-fields-have-extra-newlinescarriage-returns-n-and-r/#comments Tue, 25 Nov 2008 04:59:09 +0000 Dan http://localhost/dan/?p=204 I’ve discovered a few interesting quirks of text fields while I’ve been working with Flash lately and want to share one with you (I’ll share the other in a later post). While working with TextField objects, I noticed that a carriage return is appended to any value that is entered into a text field in the Flash IDE. However, this is not so when the text property of the TextField object is modified with ActionScript. Essentially, this adds an unexpected character to text fields created in Flash’s IDE that have not been modified with ActionScript, which can cause confusion if you are using ActionScript to work with text fields that have been placed on the stage.

The first step to understanding the problem is to create a text field in the Flash IDE and take a look at its text property and how its characters are counted both before and after modifying it with ActionScript. Some example code is posted below (the first comment explains how to use it):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
* StringTest
* By Dan - http://thewebpageofdan.com
*
* To use this class, create a new Flash file with a text field and enter some text in
* it. Give it an instance name and change the textFieldInstance property of this class
* to that name.  Set this class as the "Document class" of the Flash file, then create
* the swf and run it.
*/
package
{
	import flash.display.MovieClip;
	import flash.text.TextField;
 
	public class StringTest extends MovieClip
	{
		private const textFieldInstance:String = "blah_txt";
 
		public function StringTest()
		{
			// Print out info on the text field's string
			traceStringInfo(this[textFieldInstance].text);
 
			// Remove the last character
			this[textFieldInstance].text = this[textFieldInstance].text.substring(0, this[textFieldInstance].text.length - 1);
 
			// Print new info
			traceStringInfo(this[textFieldInstance].text);
		}
 
		/**
		* Outputs string data
		*/
		private function traceStringInfo(string:String):void
		{
			trace('--------------');
			trace('length: ' + string.length);
			trace('text: ' + string);
			trace('--------------');
			trace();
		}
	}
}

Before changing the text of the text field with ActionScript the text value has a mysterious “ghost character” (carriage return) added to the end of it. Strange, no?

Another thing to think about is if text fields in your Flash application are coming from an outside data source (like XML), which may be populated by external applications (such as a PHP, Perl, or C++ script), which may be accepting data from users with different operating systems. The reason why this is important is because carriage returns are different on Linux (”\n”), Mac (”\r”), and Windows (”\r\n”) and the application(s) that store this data may or may not be taking the operating system into consideration and storing it in a uniform way. Thus, it’s possible your Flash application may be importing data with values for text fields that may contain different character combinations that are meant to represent line breaks.

This made me think a bit more about extracting the exact number of characters in a text field. I currently use this function/method to have strings with standard line breaks and no trailing white space:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
* Changes all line breaks to "\n" and removes trailing white space from a string.
* By Dan - http://thewebpageofdan.com
*/
private function fixString(string:String):String
{
	// Turn "\r\n" and "\r" into "\n"
	var winLineBreaks:RegExp = /\r\n/g; 
	var macLineBreaks:RegExp = /\r/g; 
 
	string.replace(winLineBreaks, "\n");
	string.replace(macLineBreaks, "\n");
 
	// Trim trailing white space
	var whiteSpace:RegExp = /\s/; 
	while (string.substring(string.length - 1, string.length).search(whiteSpace) != -1)
	{
		string = string.substring(0, string.length - 1);
	}
 
	return string;
}

And of course, to those with more information: please enlighten us :)

]]> http://www.thewebpageofdan.com/2008/11/25/actionscript-text-fields-have-extra-newlinescarriage-returns-n-and-r/feed/ 0 ActionScript Timer class seem offset/innaccurate/way off? It is! http://www.thewebpageofdan.com/2008/11/01/actionscript-timer-seem-class-innaccurateway-off-it-is/ http://www.thewebpageofdan.com/2008/11/01/actionscript-timer-seem-class-innaccurateway-off-it-is/#comments Sun, 02 Nov 2008 02:21:20 +0000 Dan http://localhost/dan/?p=165 Something I discovered a while ago has popped up in one of my old projects and I decided to share what I found. My Virtual Cube application, which renders interactive virtual Rubik’s cubes, uses timer to keep track of how long it takes a user to solve a scrambled cube. While using it, I noticed the timer running slower while using the 5×5x5 cube and faster with the 2×2x2 cube. What would be three seconds while using the small cube would be six or seven seconds for the large cube.

What was happening was the frame rate was slowing down because the Sandy 3D engine (an ActionScript 3D engine I use to render the cube) was taking longer to render the larger, and more complex, cube and all of its “cubies” that rotate. But what makes it rather odd was that this slowdown in frame rate was affecting the timer the user saw in the application. Because flash had to work harder (and longer) to display the more complex cube, it would take that much longer for my TimerEvent.TIMER event to dispatch and update my timer in the user interface.

To put it in a nutshell, the Timer class is not what you think it is (a perfect timer); it is actually influenced by the user’s frame rate. Let’s take a look at what it says right in the documentation that can be found in the Flash Help book within Flash CS or at the online Adobe® Flex™ 2 Language Reference:

You can create Timer objects to run once or repeat at specified intervals to execute code on a schedule. Depending on the SWF file’s framerate or Flash Player’s environment (available memory and other factors), Flash Player may dispatch events at slightly offset intervals. For example, if a SWF file is set to play at 10 frames per second [fps], which is 100 millisecond intervals, but your timer is set to fire an event at 80 milliseconds, Flash Player will fire the event close to the 100 millisecond interval. Memory-intensive scripts may also offset the events.

Tom Coxen has reported this “bug” a while ago and released some information regarding it, which I found to be a perfect solution to my problem. Below is some code he posted to reproduce the bug:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/**
* Timer inacurracy example.
* See: https://bugs.adobe.com/jira/browse/FP-34
*
* Originally by Tox Coxen - http://flashquartermaster.com
* Slight modifications by Dan - http://thewebpageofdan.com
*/
package
{
	import flash.display.MovieClip;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
	import flash.utils.getTimer;
 
	public class TimerTest extends MovieClip
	{
		private var _start:uint;
   		private var _desiredDelay:Number = 1000;
 
		public function TimerTest()
		{
			var timer:Timer = new Timer(_desiredDelay);
			timer.addEventListener(TimerEvent.TIMER, tick);
			_start = getTimer();
			timer.start();
		}
 
		private function tick(evt:TimerEvent):void
		{
			var timer:Timer = Timer(evt.currentTarget);
			var elapsed:Number = (getTimer() - _start);
			var desiredElapsed:Number = (timer.currentCount * _desiredDelay);
			var offset:Number = elapsed - desiredElapsed;
 
			if (offset > 1000)
			{
				trace("MORE THAN A SECOND OFF!");
			}
			trace("Tick | Count: " + timer.currentCount + " / desired Elpased millis " + desiredElapsed + " / getTimer() elapsed millis: " + elapsed + " / offset: " + offset);
		}
	}
}

Here are the results I get from running it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Tick | Count: 1 / desired elapsed millis 1000 / getTimer() elapsed millis: 1059 / offset: 59
Tick | Count: 2 / desired elapsed millis 2000 / getTimer() elapsed millis: 2112 / offset: 112
Tick | Count: 3 / desired elapsed millis 3000 / getTimer() elapsed millis: 3175 / offset: 175
Tick | Count: 4 / desired elapsed millis 4000 / getTimer() elapsed millis: 4247 / offset: 247
Tick | Count: 5 / desired elapsed millis 5000 / getTimer() elapsed millis: 5311 / offset: 311
Tick | Count: 6 / desired elapsed millis 6000 / getTimer() elapsed millis: 6390 / offset: 390
Tick | Count: 7 / desired elapsed millis 7000 / getTimer() elapsed millis: 7463 / offset: 463
Tick | Count: 8 / desired elapsed millis 8000 / getTimer() elapsed millis: 8511 / offset: 511
Tick | Count: 9 / desired elapsed millis 9000 / getTimer() elapsed millis: 9559 / offset: 559
Tick | Count: 10 / desired elapsed millis 10000 / getTimer() elapsed millis: 10607 / offset: 607
Tick | Count: 11 / desired elapsed millis 11000 / getTimer() elapsed millis: 11671 / offset: 671
Tick | Count: 12 / desired elapsed millis 12000 / getTimer() elapsed millis: 12687 / offset: 687
Tick | Count: 13 / desired elapsed millis 13000 / getTimer() elapsed millis: 13689 / offset: 689
Tick | Count: 14 / desired elapsed millis 14000 / getTimer() elapsed millis: 14759 / offset: 759
Tick | Count: 15 / desired elapsed millis 15000 / getTimer() elapsed millis: 15767 / offset: 767
Tick | Count: 16 / desired elapsed millis 16000 / getTimer() elapsed millis: 16823 / offset: 823
Tick | Count: 17 / desired elapsed millis 17000 / getTimer() elapsed millis: 17871 / offset: 871
Tick | Count: 18 / desired elapsed millis 18000 / getTimer() elapsed millis: 18918 / offset: 918
Tick | Count: 19 / desired elapsed millis 19000 / getTimer() elapsed millis: 19927 / offset: 927
Tick | Count: 20 / desired elapsed millis 20000 / getTimer() elapsed millis: 20983 / offset: 983
MORE THAN A SECOND OFF!
Tick | Count: 21 / desired elapsed millis 21000 / getTimer() elapsed millis: 22038 / offset: 1038
MORE THAN A SECOND OFF!
Tick | Count: 22 / desired elapsed millis 22000 / getTimer() elapsed millis: 23119 / offset: 1119

Basically, what this demonstrates, is that as the Timer class “ticks” can become more and more inaccurate. Personally, I think the Adobe needs to come up with a better solution for a timer with ActionScript because of how misleading this is to Flash developers using ActionScript 3.0, even though it is stated clearly in the documentation. Luckily, Tom posted an ActionScript class with his bug report to use as a workaround. A modified version, which I now use on all my Flash projects that require a “real” timer, is posted below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/**
* Workaround for Timer offsets
* See: https://bugs.adobe.com/jira/browse/FP-34
*
* Originally by Tox Coxen - http://flashquartermaster.com
* Edited by Dan - http://thewebpageofdan.com
*/
package
{
	import flash.utils.Timer;
	import flash.utils.getTimer;
 
	public class TimerReal extends Timer
	{
		private var _desiredDelay:Number;
		private var _initStart:Number;
   		private var _stop:Number;
   		private var _start:Number;
   		private var _pauses:Number;
		private var _offset:Number;
 
		/**
		* Constructs a new RealTimer object with the specified <code>delay</code> and <code>repeatCount</code> states. 
		* 
		* @param delay		The delay between timer events, in milliseconds. 
		* @param repeatCount	Specifies the number of repetitions. If zero, the timer repeats infinitely. If nonzero, the timer runs the specified number of times and then stops. 
		*/
		public function TimerReal(delay:Number, repeatCount:int = 0.0)
		{
			_desiredDelay = delay;
			_initStart = 0;
			_start = 0;
			_stop = 0;
			_pauses = 0;
			super(delay, repeatCount);
		}
 
		/**
		* Manages the timer drift and accounts for pauses caused by stopping and starting the Timer.
		*/
		public function adjustDelay():void
		{
			// Aggregate pauses.
			// When start and stop are called internally in flash.utils.Timer _start will equal _stop
			_pauses += _start - _stop;
 
			var elapsed:Number = (getTimer() - _initStart) - _pauses;
			var desiredElapsed:Number = (currentCount * _desiredDelay);
			_offset = elapsed - desiredElapsed;
			var newDelay:Number = _desiredDelay - _offset;
 
			// Setting negetive values for delay will cause an error
			delay = (newDelay > 0) ? newDelay : _desiredDelay;
		}
 
		/**
		* @private
		*/
		override public function start():void
		{
			// Set _initStart once only otherwise set a value for when Timer.start() is called
			if (_initStart == 0)
			{
				_initStart = getTimer();
			}
			else
			{
				_start = getTimer();
			}
			super.start();
		}
 
		/**
		* @private
		*/
		override public function stop():void
		{
			// Only set the stop value if the Timer has been started and needs to be stopped i.e. is running
			if (_initStart != 0 && running)
			{
				_stop = getTimer();
			}
			super.stop();
		}
 
		/**
		* @private
		*/
		override public function reset():void
		{
			_initStart = 0;
			_start = 0;
			_stop = 0;
			_pauses = 0;
			super.reset();
		}
 
		/**
		* The desired delay.
		*/
		public function set desiredDelay(value:Number):void
		{
			_desiredDelay = value;
		}
 
		/**
		* The current offset.
		*/
		public function get offset():Number
		{
			return _offset;
		}
	}
}

This class keeps track of how much “real” time is passing while the timer is running by using the getTimer() function. The adjustDelay() method computes the offset and adjusts the delay property. Here is an example of how you could use the class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/**
* TimerReal example.
* By Dan - http://thewebpageofdan.com
*/
package
{
	import flash.display.MovieClip;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
	import flash.utils.getTimer;
 
	public class TimerRealExample extends MovieClip
	{
		public function TimerRealExample()
		{
			var timer:TimerReal = new TimerReal(10);
			timer.addEventListener(TimerEvent.TIMER, tick);
			timer.start();
		}
 
		private function tick(evt:TimerEvent):void
		{
			TimerReal(evt.currentTarget).adjustDelay();
			var timeStr:String = millisToTimeStr(evt.target.currentCount + evt.target.offset / 10);
			trace(timeStr);
		}
 
		/**
		* Converts milliseconds to a time string
		*/
		private function millisToTimeStr(milliseconds:uint):String
		{
			var seconds:uint = Math.floor(milliseconds / 100);
			var minutes:uint = Math.floor(seconds / 60);
			var hours:uint = Math.floor(minutes / 60);
 
			var lminutes:uint = minutes - (hours * 60);
			var lseconds:uint = seconds - (minutes * 60);
			var lmilliseconds:uint = milliseconds - seconds * 100;
 
			var millisecondsStr:String = (lmilliseconds >= 10) ? String(lmilliseconds) : "0" + lmilliseconds;
			var secondsStr:String = (lseconds >= 10) ? String(lseconds) : "0" + lseconds;
			var minutesStr:String = (lminutes >= 10) ? String(lminutes) : "0" + lminutes;
			var hoursStr:String = (hours >= 10) ? String(hours) : "0" + hours;
 
			return String(((hours) ? hoursStr + ":" : "") + minutesStr + ":" + secondsStr + "." + millisecondsStr);
		}
	}
}

Note: It’s important to remember that the Timer class’s TimerEvent.TIMER event will still dispatch at incorrect intervals, but this fix will help to adjust its currentCount property. If anyone dives deeper into this, let me know what you find!

]]> http://www.thewebpageofdan.com/2008/11/01/actionscript-timer-seem-class-innaccurateway-off-it-is/feed/ 0 Flash Help Book Creator http://www.thewebpageofdan.com/2008/06/23/flash-help-book-creator/ http://www.thewebpageofdan.com/2008/06/23/flash-help-book-creator/#comments Mon, 23 Jun 2008 18:13:18 +0000 Dan http://www.thewebpageofdan.com/news/?p=13 Flash Help Book Creator is a tool to create a Flash extension for an ActionScript library that adds a help book to Flash Help and adds syntax highlighting and code hints to the editor. It started out as something solely for the Sandy 3D engine, but I decided to make it public since it’s a helpful application that others may find useful. If you have an ActionScript library that you support, this is what will integrate your code into the Flash IDE. So be sure to give it a try.

]]> http://www.thewebpageofdan.com/2008/06/23/flash-help-book-creator/feed/ 0 WebDevPage: A helpful page for web developers http://www.thewebpageofdan.com/2008/05/27/webdevpage-a-helpful-page-for-web-developers/ http://www.thewebpageofdan.com/2008/05/27/webdevpage-a-helpful-page-for-web-developers/#comments Tue, 27 May 2008 15:21:16 +0000 Dan http://www.thewebpageofdan.com/news/?p=12 I decided to make WebDevPage public.  It is something I’ve used for a while for determining information about users’ browsers and installed plugins.  To make it more useful to the public, I added a listing of links that I have found as useful web development resources.  Let me know if there are any problems with it.

]]> http://www.thewebpageofdan.com/2008/05/27/webdevpage-a-helpful-page-for-web-developers/feed/ 0 Virtual cube http://www.thewebpageofdan.com/2008/05/21/virtual-cube/ http://www.thewebpageofdan.com/2008/05/21/virtual-cube/#comments Wed, 21 May 2008 17:39:50 +0000 Dan http://www.thewebpageofdan.com/news/?p=11 Virtual cube is something I finished a little while ago and have been revisiting every now and then, but I think it’s time to finally post it.

The application is a virtual cube (basically a Rubik’s cube). It displays a cube that the user can manipulate by rotating both the cube itself and its different levels. I have included support for different cube sizes and a few different scramble methods.

Currently the “solver,” it’s fake :P . It simply retraces the rotations of the user (as well as the scrambler) to return the cube to its solved state. I know someone who is making a solver that will solve any size cube (NxNxN) in Java, which I will port to ActionScript and incorporate in this application. This will also allow me to make a feature where the user can “paint” the cube by individually placing the stickers on the cube since the solver will then be able to solve a cube without needing to know the rotations it takes to get to that permutation.

]]> http://www.thewebpageofdan.com/2008/05/21/virtual-cube/feed/ 4 An update?! http://www.thewebpageofdan.com/2008/05/20/an-update/ http://www.thewebpageofdan.com/2008/05/20/an-update/#comments Tue, 20 May 2008 21:22:21 +0000 Dan http://www.thewebpageofdan.com/news/?p=10 It almost took a year, but here I am, alive and posting. School is out now, so I will be cleaning up my portfolio and posting some of the things I’ve been working on. Some of them are already up and running online, let me know if there are problems. :)

]]> http://www.thewebpageofdan.com/2008/05/20/an-update/feed/ 0 New game: Tetris http://www.thewebpageofdan.com/2007/08/11/new-game-tetris/ http://www.thewebpageofdan.com/2007/08/11/new-game-tetris/#comments Sun, 12 Aug 2007 02:36:59 +0000 Dan http://www.thewebpageofdan.com/news/2007/08/11/new-game-tetris/ Tetris is one of those games that I just had to make…because I can…and I did! I tried putting in a few different game modes and will probably add some more in the future as well as more challenges.

]]> http://www.thewebpageofdan.com/2007/08/11/new-game-tetris/feed/ 0