I had a good idea the area(s) that people might like more in depth information, but I also wanted to take into account some broader work flow and process issues that I feel really need to be discussed. In this post I would like to present some more detailed information regarding one of the slides I used at the LFPUG presentation that, as expected, has generated a lot of feed back.

Managing Text & Fonts

During the presentation I had split this key area of localizing flash content into two sub-headings, each sub-heading had a number of points I wanted to cover.

Part 1 - Fonts

• Understanding character sets, character maps & glyphs tables.
• Using embedded fonts and or non-embedded fonts.
• Flash 8 and advanced anti-aliasing.
• File size implications of fonts in flash.

Part 2 - Construction & Style

• Using font symbols.
• Using dynamic text fields.
• Shared fonts, font libraries and font symbols.
• The TextFormatObject & CSS.

Understanding Character sets, character mapping and glyph tables

Before getting into the nitty gritty of the practical side of how you go about managing the text based content in a localized flash project, I want to cover off the underlying concepts and processes that support it. Hopefully my terminology will be correct enough for the purpose of this article, feel free to leave comments correcting me where appropriate.

When trying to localize text based content in flash you will need to understand a little regarding Unicode, and how the fonts and applications you are using support it. So what is Unicode.

Unicode provides a unique number for every character, no matter what the platform, no matter what the program, no matter what the language

In addition to this Unicode characters are grouped into character sets. Within flash these can be found in the embed fonts options of the text field properties inspector.

As flash developers we should be able publish content to pretty much any language on the planet. "we should be able". What often upsets this localization utopia is that many, many times we will find that the fonts provided, or requested within a project don't completely support Unicode. If this is the case it will result in a number of display issues within your flash production, including missing characters, or often a "?" or a square symbol, being displayed instead. Another, slightly less common problem can be a poorly constructed font that has characters incorrectly mapped. This would result, for example, in the glyph for "A" being returned and displayed as "B".

In actual fact there are few font faces that do fully support the whole Unicode table, and generally they are the standard system font faces for "sans", "serif", and "monospace" display, (Arial, Times, Courier on Windows). In part this is because to implement a complete Unicode font would be a time consuming and costly, production. There are around 65,000 (I think?) individual Unicode character codes to support, meaning over 65,000 characters to produce and test for some poor font maker.

With this in mind it is always worth checking the level of Unicode support that the fonts you are being asked to use support, you will save yourself a lot of tears as your project progresses.

Having assessed the support that your fonts offer for Unicode you need to find an acceptable level of Font Embedding. I have found this to be very similar in approach to deciding the compression that is applied to an image for the web. There is always going to be a trade off between the number of fonts you embed, and the final file size of a project. For example as a test, and to refresh my memory, I did an export of a flash movie that simply had a Dynamic text Field supporting Arial MS Unicode and embedding all character sets. The resultant SWF was 9.7MB uncompressed (7.8MB compressed).

The reason for large file size is that when flash embeds fonts for use in the player they are essentially converted to vector shapes that are embedded in your movie. When you get to some of the more exotic languages (Asian and Right to Left Languages for example) the individual glyphs are very elaborate, these results in some complex vectors, and thus larger file sizes. In addition the shear number of characters is HUGE, a number of languages have many more individual characters than us Europeans, the basic Korean character set has 3454 glyphs!

As of flash 8 the use of embedded fonts becomes less of an issue, with respect to visually acceptable text rendering. Making use of the advanced anti-aliasing options we are able to yield far better readability than is possible even with embedded font glyphs. However there are still some issues related to these options when trying to animate and scale text that is displayed using them. So depending on the design and visual treatment you are dealing with you will need to keep this in mind.

In my next post I will look at how to manage fonts within your files, it will roughly follow the structure of the 'part 2' heading above apply some of the code examples from my brief previous post.

References from this Article
Unicode.org, an invaluable source of information regarding UTF and Unicode
Online Unicode look up table
Information on Flash 8 text rendering issue in Saffron
Further information on Flash 8 text rendering issue in Saffron
LFPUG Presentation Running Notes

Links in this Article
London Flash Platform User Group
The presentation slides I used. More details are in the running notes above.
Code Snippets for localizing flash

Thanks to AKQA for the venue, support, beer and pizza, very nice it was to. Thanks also to Tink for the opportunity to break my cherry, so to speak. And finally thanks to every one that came along to listen to me gibbering on. It must be said this is a subject I have come to build a love-hate relationship with over the many years I have spent in the field. I love the challenge of working to localise the content. I hate the fact that Flash makes even some of the most mundane solutions or Ideas a HUGE Challenge. It would seem I am not alone in this.

In addition to nattering on myself, I also received some useful information as well, which was great. So thanks for correcting my terminology of Polish as a Cyrillic based Language. Apparently it's an Extended European language, which would account for me having issues with that one.

Something I didn't do last night was to show any code. This was due to operating on a Mac (thanks again Tink) and not being confident enough in my app switching on the alien technology. Below are some snippets I made reference to.

Using System.capabilities.playerType to allow altered path references dependent on whether you are testing through a browser.
[AS]
/*
str_xml variable is a string appended to the SWF file name in the HTML
this is used to dictate which XML language version the flash movie
will load and display. If no XML variable is detected then the movie will
default to the UK English version (en-GD) this allows for easy testing in the
flash IDE
*/
var str_defaultLang:String = "en-GB";
// use the playerType to asertain whether the movie is playing in the browser or not and alter the Pathing acordingly
var str_siteRoot: = (System.capabilities.playerType == "External") ? "../" : "";
var str_xml:String = (str_xml == undefined) ? str_defaultLang : str_xml;
var str_xmlSource:String = str_siteRoot + "xml/structure" + str_xml + ".xml";
[/AS]
A simple (nasty) prototype to string that offers find and replace functionality. This is then shown searching for pesky windows carriage return and line feed symbols and replacing them with single newline statement. I hope the URL encoded values are correct; I have actually done this from memory. Please let me know it this not the case.

[AS]
/*String object prototype adds find and replace functionality*/
/*
usage : str_myString.replace(str_stringToFind, str_stringToReplace);
str_stringToFind: string you wish to find in 'str_myString'
str_stringToReplace: string you wish to replace str_stringToFind with in 'str_myString'
returns: str_myString with all occurances of str_stringToFind replaced with str_stringToReplace
*/
String.prototype.replace = function(str_f:String, str_r:String):String
{
return (this.split(str_f).join(str_r));
}
var myString:String
myString = escape(myString)
myString = myString.replace("%0A%0D", newline);
myString = unescape(myString);
[/AS]

Finally a snippet showing how to store Country/Language code combinations in order to switch fonts to Arial MS Unicode in those more troublesome language character sets.

[AS]
/* Array to list non supported county/language codes */
var arr_nonSuportedCC:Array = new Array("gr-GR", "ru-RU", "tr-TR", "cr-CR", "kr-KR", "pl-PL", "si-SI", "cs-CZ", "da-DK", "el-GR", "sv-FI", "hu-HU");
/*
setFontFace loops trough an array of Values that represent Country/language codes for the
current content, if the current document country code is in this list then return true to
say use a default font face that supports the countries glyphs more fully.
e.g Arial Unicode MS for russian/greek/cyrilic languages
*/
var setFontFace = function(str_CC:String, arr_CountryList:Array):Boolean
{
var bln_retval:Boolean = false;
var i:Number = 0;
var iTotal:Number = arr_CountryList.length;
var str_curCC:String;
str_CC = str_CC.toLowerCase()
while(i < iTotal)
{
str_curCC = arr_CountryList[i].toLowerCase();
if (str_CC == str_curCC)
{
bln_retval = true;
i = iTotal;
}
++i;
}
return bln_retval;
}
/* switch to determin if the font glyphs are supported*/
var bln_useArial:Boolean = setFontFace(str_xml, arr_nonSuportedCC);
var str_defaultDisplayFont:String
str_defaultDisplayFont = bln_useArial ? "Arial Unicode MS" : "HelveticaNeueLT Pro 43 LtEx";
// Text Formating object that will use the 'default' or 'switched' font
__tf_navigationDefault = new TextFormat()
__tf_navigationDefault.font = str_defaultDisplayFont
__tf_navigationDefault.size = 14;
__tf_navigationDefault.color = 0x102C4A;
[/AS]

This last Snippet could also be extended to switch Font Size based on Asian Language or country codes as well. In addition I have used a similar script to check for 'preferred' fonts based on TextField.getFontList().

The Ford SAV site will be presented in 16 languages. The content and structure is stored and managed via external XML documents. All images and audio are managed via the xml along with limited control over the colours and 'skin' elements such as the background tints and locations.

There are a number of components that I produced specifically for the project; one manages the ‘sproingy’ navigation for example. Other components/classes were developed with less specific implementation in mind. For example the initial development made use of the combination LoaderClass, LoaderQueueManager, LoaderQueue. However somewhere between the need for 4 class files, the mixed of AS 1.0/AS 2.0, the 3 different authors across the files, a modified folder structure and the French only comments in some places. I decided to re-factor this simple but effective idea into a simple LoadQueueManger AS2.0 class that simply implements the inbuilt EventDispatcher Class.
Presented is only a partial implementation of this great set of files as I only needed a basic Queue and Priority functionality but once the other methods are fleshed out I will update the code here.

The following code is provided as is.
[as]/*=====================================================
LoadQueueManager
var myLoadQueManager:LoadQueueManager = new LoadQueueManager();
var myLoadItemID:Number = myLoadQueManager.load(targetObject, URL, [listenerObject]);
myLoadQueManager.addListener(listenerObject);

TODO:
complete accessors for:

loadDuration
steps
loadTime

implement loadObjectType rather than trying to work out what we are loading autoMagically

seperate object listeners, currently all loading objects listeners all listen
to all loading objects, there should be a smarter event modle that allows
individual listeners to just listen to their specific loading objects. Not all loading objects
Allthought e abillity to listen to all objects does allow for a global loading control to
listen to the entire load queue progress

Development Based on:
=====================================================
LoaderItem Class author Ralf Bokelberg http://www.helpqlodhelp.com/blog/
LoaderQueue Class author Bryan Ledford
LoaderQueue Class author erixtekila copyleft http://www.v-i-a.net

* @class LoaderClass
* Implements Colin Moock's Preloading Api as proposed
* at http://www.moock.org/blog/archives/000010.html
*
* This code is supplied as is, use it at your own risk
* and please don't remove this header.
*
* If you plan to use the code on a commercial site,
* we would happily receive a donation to
* paypal@helpqlodhelp.com. See the docs for the details
*
* Version 1.02
* Date 2003/06/16
* Author Ralf Bokelberg
*
* Version 1.2
* Date 2003/10/27
* Author Bryan Ledford
* Rewrote for AS 2.0
* Added Alex Uhlmann's Priority methods [setPriority, getPriority]
*

i Hope this information is complete enough not please advise.
=====================================================*/

import mx.events.EventDispatcher;
class LoadQueueManager
{
private static var symbolName:String = "LoadQueueManager";
private static var className:String = "LoadQueueManager";
private static var _instance:LoadQueueManager;

private static var __int_defaultTimeoutMS:Number = 10000;
private static var __int_defaultIntervalMS:Number = 100;
private static var __int_defaultMinSteps:Number = 5;

private var __arr_curQueue:Array;

private var __bln_autoLoad:Boolean = true;
private var __bln_isLoading:Boolean = false;
private var __bln_isPaused:Boolean = false;
private var __bln_hasTimedOut:Boolean = false;

private var __int_loadDurationCurrent:Number = 0;
private var __int_loadDurationTotal:Number = 0;
private var __int_loadSpeed:Number = 0;
private var __int_loadTimeCurrent:Number = 0;
private var __int_loadTimeTotal:Number = 0;
private var __int_percentLoadedCurrent:Number = 0;
private var __int_percentLoadedTotal:Number = 0;
private var __int_bytesLoaded:Number = 0;
private var __int_bytesTotal:Number = 0;
private var __int_timeOutMS:Number = 10000;
private var __int_loadIntervalMS:Number = 100;
private var __int_steps:Number = 1;
private var __int_loadInterval:Number;
private var __int_timeInterval:Number;
private var __int_timeCurrent:Number = 0;

private var __obj_target:Number;
private var __obj_targetObject:Number;
private var __obj_currentLoadTarget:Object;
private var __obj_currentLoadListener:Object;
private var __obj_currentLoadObject:Object;

private var __mc_mcLoadSnapShot:MovieClip;

private var __str_currentLoadURL:String = "";

function dispatchEvent(){};
function addEventListener(){};
function removeEventListener(){};

public function LoadQueueManager(int_timeoutMs:Number, int_intervalMs:Number, int_minSteps:Number)
{
EventDispatcher.initialize(this);
__arr_curQueue = new Array();
}

/*=====================================================
LoadQueueManager.addListener();
used to associate a listener to all displatched events

onLoadStarted
onLoadProcess
onLoadItemComplete
onLoadComplete
onLoadPause
onLoadResume
onLoadInvalidObject
onTimeOutMSSet
onIntervalMSSet
onLoadItmeTimedOut
=====================================================*/
public function addListener(obj_listner:Object):Void
{
addEventListener("onLoadStarted", obj_listner);
addEventListener("onLoadObserveStarted", obj_listner);
addEventListener("onLoadProgress", obj_listner);
addEventListener("onLoadItemComplete", obj_listner);
addEventListener("onLoadComplete", obj_listner);
addEventListener("onLoadPause", obj_listner);
addEventListener("onLoadResume", obj_listner);
addEventListener("onLoadInvalidObject", obj_listner);
addEventListener("onTimeOutMSSet", obj_listner);
addEventListener("onIntervalMSSet", obj_listner);
addEventListener("onLoadItmeTimedOut", obj_listner);
}

/*=====================================================
LoadQueueManager.removeListener();
used to associate a listener to all displatched events

onLoadStarted
onLoadProcess
onLoadItemComplete
onLoadComplete
onLoadPause
onLoadResume
onLoadInvalidObject
onTimeOutMSSet
onIntervalMSSet
onLoadItmeTimedOut
=====================================================*/
public function removeListener(obj_listner:Object):Void
{
removeEventListener("onLoadStarted", obj_listner);
removeEventListener("onLoadObserveStarted", obj_listner);
removeEventListener("onLoadProgress", obj_listner);
removeEventListener("onLoadItemComplete", obj_listner);
removeEventListener("onLoadComplete", obj_listner);
removeEventListener("onLoadPause", obj_listner);
removeEventListener("onLoadResume", obj_listner);
removeEventListener("onLoadInvalidObject", obj_listner);
removeEventListener("onTimeOutMSSet", obj_listner);
removeEventListener("onIntervalMSSet", obj_listner);
removeEventListener("onLoadItmeTimedOut", obj_listner);
}
/*=====================================================
Que Manager Control Methods
=====================================================*/

/*=====================================================
LoadQueueManager.load();
@param obj_target a reference to the object that will hold the loaded asset
@param str_URl the url to the asset that will be loaded
@param obj_listener [option] a listener object specifically for this load item
@return the index of the item in teh load queue array of the loadManager
=====================================================*/
public function load(obj_target:Object, str_URl:String, obj_listener:Object):Number
{
var int_retVal:Number = -1;
var bln_validLoadObject:Boolean = (locationToTarget(obj_target) != undefined);
if(obj_listener != undefined) addListener(obj_listener);

if(!bln_validLoadObject)
{
dispatchEvent({type:"onLoadInvalidObject",target:this});
return int_retVal;
}

var obj_loadObj:Object = new Object();
obj_loadObj._target = locationToTarget(obj_target);
obj_loadObj._url = str_URl;
obj_loadObj._listener = obj_listener;
obj_loadObj._priority = ((loadQueue.push(obj_loadObj)) -1);

int_retVal = obj_loadObj._priority;
if (!isLoading && autoLoad)
{
dispatchEvent({type:"onLoadStarted",target:this, loadObject:currentLoadObject});
startLoading();
}

return int_retVal;
}

/*=====================================================
LoadQueueManager.loadAtPriority();
pauses the current load operation if the priority is 0, any partially loaded asset will be unloaded and lost.
adds the target clip at the priority specified by int_priority
Then restarts the load que manager if it was paused, or resarts the load queue is it is not loading.
@param obj_target a reference to the object that will hold the loaded asset
@param str_URl the url to the asset that will be loaded
@param int_priority an integer that represents the priority the object should be loaded at
@param obj_listener [option] a listener object specifically for this load item
@return the index of the item in teh load queue array of the loadManager
=====================================================*/
public function loadAtPriority(obj_target:Object, str_URl:String, int_priority:Number, obj_listener:Object):Number
{
if((int_priority === 0) && isLoading)pause();

var int_retVal:Number = -1;
var bln_validLoadObject:Boolean = (locationToTarget(obj_target) != undefined);
if(obj_listener != undefined) addListener(obj_listener);

if(!bln_validLoadObject)
{
dispatchEvent({type:"onLoadInvalidObject",target:this});
return int_retVal;
}

var obj_loadObj:Object = new Object();
obj_loadObj._target = locationToTarget(obj_target);
obj_loadObj._url = str_URl;
obj_loadObj._listener = obj_listener;
obj_loadObj._priority = int_priority;
loadQueue.splice(int_priority, 0, obj_loadObj);

trace("load queue == "+ loadQueue + " -- " + isPaused + " -- " + isLoading);

int_retVal = obj_loadObj._priority;

if (!isLoading && autoLoad)
{
dispatchEvent({type:"onLoadStarted",target:this, loadObject:currentLoadObject});
startLoading();
}
else if (isPaused)
{
resume();
}

return int_retVal;
}

/*=====================================================
LoadQueueManager.stop();
stops the load manager and resets the current load queue
similar to clear in teh old load queu manager
=====================================================*/
public function stop():Void
{
endInterval();
__arr_curQueue.length = 0;
__arr_curQueue = undefined;
delete __arr_curQueue;
__arr_curQueue = new Array();
__bln_isPaused = __bln_isLoading = false;
}

/*=====================================================
LoadQueueManager.observe();
pauses the current load operation any partially loaded asset will be unloaded and lost.
Then and adds the target clip as a priority 0 object to the load queue
Then restarts the load que manager.
@param obj_target a reference to the object that will hold the loaded asset
@param obj_listener [option] a listener object specifically for this load item
=====================================================*/
public function observe(obj_target:Object, obj_listener:Object):Void
{
if(isLoading)pause();
var bln_validLoadObject:Boolean = (locationToTarget(obj_target) != undefined);
if(obj_listener != undefined) addListener(obj_listener);

if(!bln_validLoadObject)
{
dispatchEvent({type:"onLoadInvalidObject",target:this});
return;
}

var obj_loadObj:Object = new Object();
obj_loadObj._target = locationToTarget(obj_target);
obj_loadObj._url = undefined;
obj_loadObj._listener = obj_listener;
obj_loadObj._priority = undefined;

loadQueue.splice(0, 0, obj_loadObj);

if(isPaused)
{
resume();
}
else
{
startLoading();
}
dispatchEvent({type:"onLoadObserveStarted",target:this, loadObject:currentLoadObject});
}

/*=====================================================
LoadQueueManager.pause();
pauses the current load operation any partially loaded asset will be unloaded and lost.
=====================================================*/
public function pause():Boolean
{
if(isPaused) return false;

pauseLoading();

dispatchEvent({type:"onLoadPause",target:this, loadObject:currentLoadObject});
return true;
}

/*=====================================================
LoadQueueManager.resume();
resumes the current load operation from the point at wich it
was paused. Any parially loaded assets will begin to load from
scratch
=====================================================*/
public function resume():Boolean
{
if(!isPaused) return false;
if(isLoading) return false;

resumeLoading();

dispatchEvent({type:"onLoadResume",target:this, loadObject:currentLoadObject});
return true;
}

/* unused methods for removing items from the queue
public function removeItem()
{
}
public function removeItemAt(int_i:Number)
{
}
public function removeItems(arr_i:Array)
{
}
*/

/*=====================================================
LoadQueueManager.setPriority();
pauses the current load operation any partially loaded asset will be unloaded and lost.
alters the order of the load queue and then resstarts the load manager from priority 0.
@param int_priority the desired target priority (0 - loadQueue.length, 0 is highest priority)
@param obj_targetItem the target objects current priority, or the URL of the asset that is
associated with the loadItem
@return success or error code as an integer
=====================================================*/
public function setPriority(int_priority:Number, obj_targetItem):Number
{
var int_retVal:Number = -1;
var int_qLength = loadQueue.length;
var obj_tItem:Object;
// return an eror code as the queue has no items in
if(!int_qLength) return int_retVal;
// return an eror code as the target priority is outside the bounds of the current queue
if(int_priority < 0 || int_priority > int_qLength) return -2;

obj_tItem = getTargetItemObject(obj_targetItem);
// return an eror code as the target item is not in the queue
if(obj_tItem == undefined) return -3;
// return an eror code as the target priority is the current item priority
if(obj_tItem._priority == int_priority) return -4

pauseLoading();
moveQueueItem(obj_tItem.index, int_priority)
resumeLoading();

int_retVal = obj_tItem.index;
return int_retVal;
}

/*=====================================================
LoadQueueManager.getPriority();
@return priority (id) of the currently loading item
=====================================================*/
public function getPriority():Number
{
return currentLoadObject._priority;
}

public function getTargetItemObject(_val):Object
{
var obj_retVal:Object;
var int_findByPriority:Boolean = (typeof(_val) == "number");

obj_retVal = int_findByPriority ? findObjectByPriority(_val) : findObjectByURL(_val);

return obj_retVal;
}

public function setPriorityAt(obj_i, int_i:Number, int_priority:Number)
{
var int_qLength = loadQueue.length;
}
public function getPriorityAt(obj_i, int_i:Number, int_priority:Number):Number
{
return currentLoadObject._priority;
}

public function getBytesLoaded():Number
{
return bytesLoaded;
}
public function getBytesTotal():Number
{
return bytesTotal;
}

/*=====================================================
Read Only Properties
=====================================================*/
public function get isLoading():Boolean
{
return __bln_isLoading;
}
public function get isPaused():Boolean
{
return __bln_isPaused;
}
public function get loadSpeed():Number
{
return __int_loadSpeed;
}
public function get loadDurationCurrent():Number
{
return __int_loadDurationCurrent;
}

public function get loadTimeCurrent():Number
{
return __int_loadTimeCurrent;
}
public function get percentLoaded():Number
{
return __int_percentLoadedCurrent;
}

public function get bytesLoaded():Number
{
return __int_bytesLoaded;
}
public function get bytesTotal():Number
{
return __int_bytesTotal;
}
public function get target():Object
{
return currentLoadObject._target;
}
public function get targetPath():String
{
return typeof target == "movieclip" ? targetPath (target) : target;
}
public function get targetURL():String
{
return currentLoadObject._url;
}
public function get currentLoadObject():Object
{
return __obj_currentLoadObject;
}
public function get loadQueue():Array
{
return __arr_curQueue;
}

/* unused read only properties
public function get loadDurationTotal():Number
{
return __int_loadDurationTotal;
}
public function get loadTimeTotal():Number
{
return __int_loadTimeTotal;
}
*/

/*=====================================================
Read and Write Properties
=====================================================*/
public function set autoLoad(bln_i:Boolean)
{
__bln_autoLoad = bln_i;
}
public function get autoLoad():Boolean
{
return __bln_autoLoad;
}

public function set intervalMS(int_i:Number)
{
var bln_useDefaultInterval:Boolean = (int_i < 0 || int_i == 0);
__int_loadIntervalMS = bln_useDefaultInterval ? __int_defaultIntervalMS : int_i;
dispatchEvent({type:"onIntervalMSSet",target:this, value:bln_useDefaultInterval});
}
public function get intervalMS():Number
{
return __int_loadIntervalMS;
}

public function set timeOutMS(int_i:Number)
{
var bln_useDefaultTimeout:Boolean = (int_i < 0 || int_i == 0);
__int_timeOutMS = bln_useDefaultTimeout ? __int_defaultTimeoutMS : int_i;
dispatchEvent({type:"onTimeOutMSSet",target:this, value:bln_useDefaultTimeout});
}
public function get timeOutMS():Number
{
return __int_timeOutMS;
}

/* unused read & write properties
public function set loadQueue(arr_i:Array)
{
__arr_curQueue = arr_i;
}

public function set steps(int_i:Number)
{
__int_steps = int_i;
}
public function get steps():Number
{
return __int_steps;
}
*/

/*=====================================================
private methods and functions
=====================================================*/
private function startLoading()
{
var int_targetLoadType:Number;
var curLoadObject:Object = loadQueue[0];
__bln_hasTimedOut = false;
__obj_currentLoadObject = curLoadObject;

__obj_currentLoadObject = curLoadObject;
__obj_currentLoadTarget = curLoadObject._target;
__obj_currentLoadListener = curLoadObject._listener;
__str_currentLoadURL = curLoadObject._url;
__bln_isLoading = true;

int_targetLoadType = targetLoadType(locationToTarget(__obj_currentLoadTarget));
if(locationIsLevel(__obj_currentLoadTarget)) int_targetLoadType = 4;
if(__str_currentLoadURL == undefined) int_targetLoadType = -1;
switch(int_targetLoadType)
{
case -1:
// the load object is an observe not a load
__bln_isLoading = true;
break;
case 4:
// load target in to level
loadMovie( __str_currentLoadURL, __obj_currentLoadTarget);
__bln_isLoading = true;
break;
case 3:
// load target into movieclip
__obj_currentLoadTarget.loadMovie(__str_currentLoadURL);
__bln_isLoading = true;
break;
case 2:
// load target into sound
__obj_currentLoadTarget.loadSound(__str_currentLoadURL);
__bln_isLoading = true;
break;
case 1:
// load target into mxl, or load vars object
__obj_currentLoadTarget.load(__str_currentLoadURL);
__bln_isLoading = true;
break;
default:
// load target is not a valid location
__bln_isLoading = false;
break;
}
if(isLoading) startInterval();
}

private function pauseLoading()
{
var int_targetLoadType:Number = targetLoadType(locationToTarget(__obj_currentLoadTarget));
if(locationIsLevel(__obj_currentLoadTarget)) int_targetLoadType = 4;

switch(int_targetLoadType)
{
case 4:
// load target in to level
loadMovie(undefined, __obj_currentLoadTarget);
unloadMovie(__obj_currentLoadTarget);
break;
case 3:
// load target into movieclip
__obj_currentLoadTarget.loadMovie(undefined);
break;
case 2:
// load target into sound
__obj_currentLoadTarget.loadSound(undefined);
break;
case 1:
// load target into mxl, or load vars object
__obj_currentLoadTarget.load(undefined);
break;
}

__bln_isPaused = true;
__bln_isLoading = false;
endInterval();
}

private function resumeLoading()
{
__bln_isPaused = false;
startLoading();
}
/*
set the loading interval
*/
private function startInterval():Void
{
if (__int_loadInterval != undefined)
{
endInterval();
}
__int_loadInterval = setInterval(this, "onInterval", intervalMS);
__int_timeInterval = setInterval(this, "startTimeOut", 1);
}
/*
set the timeout interval
*/
private function startTimeOut():Void
{
if(++__int_timeCurrent >= timeOutMS && !checkBytesTotal() && !checkBytesLoaded())
{
__bln_hasTimedOut = true;
endTimeOut();
}
}
/*
remove the timeout interval
*/
private function endTimeOut():Void
{
clearInterval ();
__int_timeInterval = undefined;
__int_timeCurrent = 0;
}
/*
remove loading interval
*/
private function endInterval():Void
{
if (__int_loadInterval != undefined)
{
clearInterval (__int_loadInterval);
__int_loadInterval
}
}

/*
the loading progress interval function
*/
private function onInterval():Void
{
var currentLoc = targetToLoc(target);
if (! checkBytesTotal (currentLoc)) return;
if (! checkBytesLoaded (currentLoc)) return;

// check to see if the item has loaded
if(checkComplete(currentLoc))
{
dispatchEvent({type:"onLoadItemComplete",target:this, loadObject:currentLoadObject});
if(currentLoadObject._listener != undefined) removeListener(currentLoadObject._listener);
endInterval();
loadQueue.splice(0, 1);
loadNext();
return;
}
// check to see if the item has timed out
else if(__bln_hasTimedOut)
{
endInterval();
__arr_curQueue = loadQueue.splice(0, 1);
dispatchEvent({type:"onLoadItmeTimedOut",target:this, loadObject:currentLoadObject});
loadNext();
return;
}

dispatchEvent({type:"onLoadProgress",target:this});
}

/*
checks to see if there are any other items to load in the load queue
if there are not then the queue is loaded, other wise load the next
item in teh queue
*/
private function loadNext():Void
{
if(checkLoadQueue())
{
startLoading();
}
else
{
__bln_isLoading = false;
__bln_isPaused = false;

dispatchEvent({type:"onLoadComplete",target:this});
}
}

private function targetLoadType(_val):Number
{
var int_retVal:Number = 0;

if(typeof(_val.load) == "function")
{
int_retVal = 1;
}
else if(typeof(_val.loadSound) == "function")
{
int_retVal = 2;
}
else if(typeof(_val.loadMovie) == "function")
{
int_retVal = 3;
}
if(typeof(_val) == "string" || locationIsLevel(_val))
{
int_retVal = 4;
}
return int_retVal;
}

private function targetToLoc(_val)
{
return ( typeof(_val) == 'string') ? eval(String(_val)) : _val;
}

private function targetToString(_val):String
{
return String(_val);
}

private function locationToTarget(_val):Object
{
var int_loactionType:Number = getLocationType(_val);
var obj_retval:Object;

switch(int_loactionType)
{
case 1:
obj_retval = "_level" + _val;
break;
case 0:
case 2:
case 3:
case 4:
obj_retval = _val;
break;
case 5:
if(locationIsLevelPath(_val))
{
obj_retval = eval(String(_val));
break;
}
else if(typeof(_val) == "string" && _val.length > 0)
{
obj_retval = _val;
}
break;
default:
obj_retval = undefined;
}

return obj_retval;
}

private function getLocationType(_val):Number
{
var int_retVal:Number = -1;
if(!locationIsLoadable(_val))

var str_valType:String = typeof(_val);
switch(str_valType)
{
case "number":
int_retVal = 1;
break;
case "movieclip":
int_retVal = 2;
break;
case "xml":
int_retVal = 3;
break;
case "sound":
int_retVal = 4;
break;
case "string":
int_retVal = 5;
break;
default:
int_retVal = 0;
break;
}

return int_retVal;
}

private function locationIsLoadable(_val):Boolean
{
var bln_retVal:Boolean = typeof(_val.getBytesTotal) == "function" && typeof(_val.getBytesLoaded) == "function";

return bln_retVal;
}

private function locationIsLevelPath(_val):Boolean
{
var bln_retVal:Boolean = false;

bln_retVal = (locationIsLevel (_val) && locationIsPath (_val));

return bln_retVal;
}

private function locationIsLevel(_val):Boolean
{
var bln_retVal:Boolean = _val.indexOf("_level") == 0 && ! isNaN(_val.substring(6));

return bln_retVal;
}

private function locationIsPath(_val):Boolean
{
var bln_retVal:Boolean = (typeof(_val) == "string") && (typeof(eval(String(_val))) == "movieclip") && (eval(String(_val)) != _level0 || _val == "_level0");

return bln_retVal
}

private function checkBytesTotal (_val):Boolean
{
var int_BytesTotal:Number = _val.getBytesTotal();
if (isNaN(int_BytesTotal))
{
__int_bytesTotal = null;
return false;
}
__int_bytesTotal = int_BytesTotal;
return true;
}

private function checkBytesLoaded (_val):Boolean
{
var int_BytesLoaded:Number = _val.getBytesLoaded();
if (isNaN(int_BytesLoaded))
{
__int_bytesLoaded = null;
return false;
}
__int_bytesLoaded = int_BytesLoaded;
return true;
}

private function checkComplete (_val):Boolean
{
var bln_retVal:Boolean = false;
var int_bTotal = bytesTotal;
var int_bLoaded = bytesLoaded;
var int_bPercentLoaded = __int_percentLoadedCurrent = Math.ceil((bytesLoaded / bytesTotal)*100);

if(int_bTotal == null) trace("item total is null");
if(int_bLoaded == null) trace("item loaded is null");

if(int_bTotal === int_bLoaded)
{
// item is loaded
bln_retVal = true;
}
else if(!isNaN(int_bPercentLoaded))
{
// item is still loading
bln_retVal = false;
}
return bln_retVal;
}

private function checkLoadQueue():Boolean
{
var bln_qLength:Boolean = (loadQueue.length > 0);
return bln_qLength;
}

private function findObjectByPriority(int_i:Number):Object
{
var int_qLength = loadQueue.length;
var obj_curLoadObject:Object;
var obj_retVal:Object;
var i:Number = 0;

while(i < int_qLength)
{
obj_curLoadObject = loadQueue[i];
if(obj_curLoadObject._priority === int_i)
{
obj_retVal = {target:loadQueue[i], index:i};
i = int_qLength;
}
++i;
}

return obj_retVal;
}

private function findObjectByURL(str_i:String):Object
{
var int_qLength = loadQueue.length;
var obj_curLoadObject:Object;
var obj_retVal:Object;
var i:Number = 0;

while(i < int_qLength)
{
obj_curLoadObject = loadQueue[i];
if(obj_curLoadObject._url.toLowerCase() === str_i.toLowerCase() )
{
obj_retVal = {target:loadQueue[i], index:i};
i = int_qLength;
}
++i;
}

return obj_retVal;
}

private function moveQueueItem(int_curIndex:Number, int_newIndex:Number):Boolean
{
var bln_retVal:Boolean = true;
loadQueue.splice(int_newIndex, 0, loadQueue.splice(int_curIndex, 1)[0]);
return bln_retVal;
}
}[/as]

Currently the Ford micro site is live in the following languages.
German
Netherlands
Spanish
Italian
Belgium French
Belgium Dutch