<?xml version="1.0"?>
<apiPackage id="flash.system"><apiName>flash.system</apiName><apiDetail/><apiClassifier id="flash.system:Security"><apiName>Security</apiName><shortdesc>
 The Security class lets you specify how content in different domains can communicate with 
 each other.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, XMLNode object, built-in class
 </keyword></asCustoms></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 The Security class lets you specify how content in different domains can communicate with 
 each other.
 
 </apiDesc><example conref="examples\SecurityExample.as"> The following example shows how a <codeph>click</codeph> event on a Sprite object can be
 used to show the Local Storage Settings panel of the Flash Player Settings.  An orange box is added to the 
 stage using <codeph>draw()</codeph>.  In <codeph>draw()</codeph>, a <codeph>click</codeph> event listener is 
 added named <codeph>clickHandler()</codeph>, which responds to <codeph>click</codeph> events by directing
 Flash Player to open its Local Storage Settings panel.
<codeblock>
package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.events.*;
    import flash.system.Security;
    import flash.system.SecurityPanel;

    public class SecurityExample extends Sprite {
        private var bgColor:uint = 0xFFCC00;
        private var size:uint = 100;

        public function SecurityExample() {
            draw();
        }

        private function draw():void {
            var child:Sprite = new Sprite();
            child.graphics.beginFill(bgColor);
            child.graphics.drawRect(0, 0, size, size);
            child.graphics.endFill();
            child.buttonMode = true;

            var label:TextField = new TextField();
            label.text = "settings";
            label.selectable = false;
            label.mouseEnabled = false;
            child.addChild(label);

            child.addEventListener(MouseEvent.CLICK, clickHandler);
            addChild(child);
        }

        private function clickHandler(event:MouseEvent):void {
            Security.showSettings(SecurityPanel.LOCAL_STORAGE);
        }
    }
}
</codeblock></example></apiClassifierDetail><apiOperation id="flash.system:Security:allowDomain"><apiName>allowDomain</apiName><shortdesc>
     Lets SWF files in the identified domains access objects and variables 
     in the SWF file that contains the allowDomain() call.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.allowDomain, allowDomain
     </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiException><apiDesc>Calling this method from code in the AIR application security sandbox
     throws a SecurityError exception. Content outside of the application security sandbox cannot cross-script
     content in the application security sandbox. 
     
     </apiDesc><apiItemName>SecurityError</apiItemName><apiOperationClassifier>SecurityError</apiOperationClassifier></apiException><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>domains</apiItemName><apiType value="restParam"/><apiDesc>One or more strings or URLRequest objects that name the domains from which
     you want to allow access.  You can specify the special domain "~~" to
     allow access from all domains.  
     
     <p product="flashonly">Specifying "~~" is the only
     way to allow access to nonlocal SWF files from local SWF files that have been
     published using Access Network Only for the Local Playback
     Security option in the Flash authoring tool.</p>
     
     </apiDesc></apiParam><apiTipTexts><apiTipText>Lets SWF files and HTML files access objects and variables in the calling SWF file.
     
     </apiTipText></apiTipTexts></apiOperationDef><apiDesc>
     <ph platform="actionscript">Lets SWF files in the identified domains access objects and variables 
     in the SWF file that contains the <codeph>allowDomain()</codeph> call. </ph>
     
     <p platform="javascript">This method applies to cross-scripting of ActionScript 3.0 code 
     (in SWF content). It does not apply to JavaScript code running in HTML-based AIR applications.</p>
     
     <p platform="actionscript"><i>Note:</i> Calling this method from code in the AIR application sandbox 
     throws a SecurityError exception. Content outside of the application security domain cannot directly
     cross-script content in the application sandbox. However, content outside of the application sandbox can 
     communicate with content in the application security sandbox using a sandbox bridge.</p>
     
     <p platform="actionscript">If two SWF files are served from the same domain — for example, http://mysite.com/swfA.swf and
     http://mysite.com/swfB.swf — then swfA.swf can examine and modify variables, objects, properties,
     methods, and so on in swfB.swf, and swfB.swf can do the same for swfA.swf. This is called <i>cross-movie
     scripting</i> or <i>cross-scripting</i>.</p>
     
     <p platform="actionscript">If two SWF files are served from different domains — for example, http://siteA.com/swfA.swf and
     http://siteB.com/siteB.swf — then, by default, Flash Player does not allow swfA.swf to script
     swfB.swf, nor swfB.swf to script swfA.swf. A SWF file gives SWF files from other domains
     by calling <codeph>Security.allowDomain()</codeph>. This is 
     called <i>cross-domain scripting</i>. By calling <codeph>Security.allowDomain("siteA.com")</codeph>, siteB.swf 
     gives siteA.swf permission to script it.</p>
     
     <p platform="actionscript">In any cross-domain situation, it is important to be clear about the two parties involved.
     For the purposes of this discussion, the side performing the cross-scripting
     is called the <i>accessing party</i> (usually the accessing SWF), and the other side is called <i>the party being accessed</i>  
     (usually the SWF file being accessed). When siteA.swf scripts siteB.swf, 
     siteA.swf is the accessing party, and siteB.swf is the party being accessed.</p>
     
     <p platform="actionscript"><adobeimage alt="Cross-domain diagram" href="../../images/crossScript_load.jpg"/></p>
     
     <p platform="actionscript">Cross-domain permissions that are established with <codeph>allowDomain()</codeph> are asymmetrical.
     In the previous example, siteA.swf can script siteB.swf, but siteB.swf cannot script siteA.swf, 
     because siteA.swf has not called <codeph>allowDomain()</codeph> to give SWF files at siteB.com permission 
     to script it. You can set up symmetrical permissions by having both SWF files call 
     <codeph>allowDomain()</codeph>.</p>
     
     <p platform="actionscript">In addition to protecting SWF files from cross-domain scripting originated by other SWF files, Flash Player
     protects SWF files from cross-domain scripting originated by HTML files. HTML-to-SWF scripting can
     occur with older browser functions such as <codeph>SetVariable</codeph> or callbacks
     established through <codeph>ExternalInterface.addCallback()</codeph>. When HTML-to-SWF scripting crosses
     domains, the SWF file being accessed must call <codeph>allowDomain()</codeph>, 
     just as when the accessing party is a SWF file, or the operation will fail.</p>
     
     <p platform="actionscript">Specifying an IP address as a parameter to <codeph>allowDomain()</codeph>
     does not permit access by all parties that originate at the specified IP address. 
     Instead, it permits access only by a party that contains the specified IP address it its URL, 
     rather than a domain name that maps to that IP address.</p> 
     
     <p platform="actionscript"><b>Version-specific differences</b></p>
     <p platform="actionscript">Flash Player's cross-domain security rules have evolved from version to version. 
     The following table summarizes the differences.</p>
     
     <adobetable class="innertable" platform="actionscript">
     
     
     
     
     
     <tgroup cols="5"><thead><row><entry>Latest SWF version involved in cross-scripting</entry><entry><codeph>allowDomain()</codeph> needed?</entry><entry><codeph>allowInsecureDomain()</codeph> needed?</entry><entry>Which SWF file must call <codeph>allowDomain()</codeph> or <codeph>allowInsecureDomain()</codeph>?</entry><entry>What can be specified in <codeph>allowDomain()</codeph> or <codeph>allowInsecureDomain()</codeph>?</entry></row></thead><tbody><row>
       <entry align="center">5 or earlier</entry>
       <entry>No</entry>
       <entry align="center">No</entry>
       <entry align="center">N/A</entry>
       <entry align="center">N/A</entry>
     </row><row>
       <entry align="center">6</entry>
       <entry>Yes, if superdomains don't match</entry>
       <entry align="center">No</entry>
       <entry>The SWF file being accessed, or any SWF file with the same superdomain as the SWF file being accessed</entry>
       <entry><ul>
         <li>Text-based domain (mysite.com)</li>
         <li>IP address (192.168.1.1)</li>
       </ul></entry>
     </row><row>
       <entry align="center">7</entry>
       <entry>Yes, if domains don't match exactly</entry>
       <entry>Yes, if performing HTTP-to-HTTPS access (even if domains match exactly)</entry>
       <entry>The SWF file being accessed, or any SWF file with exactly the same domain as the SWF file being accessed</entry>
       <entry><ul>
         <li>Text-based domain (mysite.com)</li>
         <li>IP address (192.168.1.1)</li>
       </ul></entry>
     </row><row>
       <entry align="center">8 or later</entry>
       <entry>Yes, if domains don't match exactly</entry>
       <entry>Yes, if performing HTTP-to-HTTPS access (even if domains match exactly)</entry>
       <entry>SWF file being accessed</entry>
       <entry><ul>
         <li>Text-based domain (mysite.com)</li>
         <li>IP address (192.168.1.1)</li>
         <li>Wildcard (~~)</li>
       </ul></entry>
     </row></tbody></tgroup></adobetable>
      
     <p platform="actionscript">The versions that control the behavior of Flash Player are <i>SWF versions</i> 
     (the published version of a SWF file), not the version of Flash Player itself. 
     For example, when Flash Player 8 is playing a SWF file published for version 7, it  
     applies behavior that is consistent with version 7. This practice ensures that player upgrades do not
     change the behavior of <codeph>Security.allowDomain()</codeph> in deployed SWF files.</p>
     
     <p platform="actionscript">The version column in the previous table shows the latest SWF version involved in a cross-scripting
     operation. Flash Player determines its behavior according to either the accessing SWF file's
     version or the version of the SWF file that is being accessed, whichever is later.</p>
     
     <p platform="actionscript">The following paragraphs provide more detail about Flash Player security changes involving
     <codeph>Security.allowDomain()</codeph>.</p>
     
     <p platform="actionscript"><b>Version 5</b>. There are no cross-domain scripting restrictions.</p>
     
     <p platform="actionscript"><b>Version 6</b>. Cross-domain scripting security is introduced. By default, Flash Player forbids
     cross-domain scripting; <codeph>Security.allowDomain()</codeph> can permit it. To determine whether two files are
     in the same domain, Flash Player uses each file's superdomain, which is the exact host name from the
     file's URL, minus the first segment, down to a minimum of two segments. For example, the superdomain of
     www.mysite.com is mysite.com. SWF files from www.mysite.com and
     store.mysite.com to script each other without a call to <codeph>Security.allowDomain()</codeph>.</p>
     
     <p platform="actionscript"><b>Version 7</b>. Superdomain matching is changed to exact domain matching. Two files are 
     permitted to script each other only if the host names in their URLs are identical; otherwise, a call to
     <codeph>Security.allowDomain()</codeph> is required. By default, files loaded from non-HTTPS URLs are no longer
     permitted to script files loaded from HTTPS URLs, even if the files are loaded from exactly the same 
     domain. This restriction helps protect HTTPS files, because a non-HTTPS file is vulnerable to
     modification during download, and a maliciously modified non-HTTPS file could corrupt an HTTPS file,
     which is otherwise immune to such tampering. <codeph>Security.allowInsecureDomain()</codeph> is introduced to
     allow HTTPS SWF files that are being accessed to voluntarily disable this restriction, but the use of
     <codeph>Security.allowInsecureDomain()</codeph> is discouraged.</p>
     
     <p platform="actionscript"><b>Version 8</b>. There are two major areas of change:</p>
     
     <ul platform="actionscript">
       <li>Calling <codeph>Security.allowDomain()</codeph> now permits cross-scripting operations
     only if the SWF file being accessed is the SWF file that called <codeph>Security.allowDomain()</codeph>. 
     In other words, a SWF file that calls <codeph>Security.allowDomain()</codeph> now permits access only to itself. 
     In previous versions, calling <codeph>Security.allowDomain()</codeph> permitted cross-scripting operations 
     where the SWF file being accessed could be any SWF file in the same domain as the SWF file that called
     <codeph>Security.allowDomain()</codeph>. Calling <codeph>Security.allowDomain()</codeph> previously opened up
     the entire domain of the calling SWF file.</li>
     
       <li>Support has been added for wildcard values with <codeph>Security.allowDomain("~~")</codeph> and 
     <codeph>Security.allowInsecureDomain("~~")</codeph>. 
     The wildcard (~~) value permits cross-scripting operations where the accessing file is any file at all,
     loaded from anywhere. Think of the wildcard as a global permission. Wildcard permissions 
     are required to enable certain kinds of operations
     under the local file security rules. Specifically, 
     for a local SWF file with network-access permissions to script a SWF file on the
     Internet, the Internet SWF file being accessed must call <codeph>Security.allowDomain("~~")</codeph>, 
     reflecting that the origin of a local SWF file is unknown. (If the Internet SWF file is loaded from an 
     HTTPS URL, the Internet SWF file must instead call <codeph>Security.allowInsecureDomain("~~")</codeph>.)</li>
     </ul>
       
     <p platform="actionscript">Occasionally, you may encounter the following situation: You load a child SWF file
     from a different domain and want to allow the child SWF file to script the parent SWF file,
     but you don't know the final domain of the child SWF file. This can happen, for
     example, when you use load-balancing redirects or third-party servers.</p>
     
     <p platform="actionscript">In this situation, you can use the <codeph>url</codeph> property of the URLRequest object
     that you pass to <codeph>Loader.load()</codeph>. For example, if you load a child SWF file 
     into a parent SWF, you can access the <codeph>contentLoaderInfo</codeph> property of the Loader
     object for the parent SWF: </p>
     <codeblock platform="actionscript">Security.allowDomain(loader.contentLoaderInfo.url)</codeblock>
     
     <p platform="actionscript">Make sure that you wait until the child SWF file begins loading to get the correct
     value of the <codeph>url</codeph> property. To determine when the child SWF has begun loading,
     use the <codeph>progress</codeph> event.</p>
     
     <p platform="actionscript">The opposite situation can also occur; that is, you might create a child SWF file
     that wants to allow its parent to script it, but doesn't know what the domain of its parent
     will be. In this situation, you can access the <codeph>loaderInfo</codeph> property 
     of the display object that is the SWF's root object. In the child SWF, call <codeph>
     Security.allowDomain( this.root.loaderInfo.loaderURL)</codeph>.
     You don't have to wait for the parent SWF file to load; the parent will already be 
     loaded by the time the child loads.</p>
     
     <p platform="actionscript">If you are publishing for Flash Player 8 or later, you can also handle these situations by calling
     <codeph>Security.allowDomain("~~")</codeph>. However, this can sometimes be a dangerous shortcut, 
     because it allows the calling SWF file to be accessed by any other SWF file from any domain. 
     It is usually safer to use the <codeph>_url</codeph> property.</p> 
     
     <p platform="actionscript">For more information related to security, see the following:</p>
     
     <ul platform="actionscript">
     
     <li product="flex">The <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref> in the 
     <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
     <li product="flash">The <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
       <li>The Flash Player Developer Center Topic: <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref></li>
     
     </ul>
     
     
     
     </apiDesc></apiOperationDetail><related-links><link href="flash.external.xml#ExternalInterface/addCallback()"><linktext>ExternalInterface.addCallback()</linktext></link><link href="flash.events.xml#Event/COMPLETE"><linktext>flash.events.Event.COMPLETE</linktext></link><link href="flash.display.xml#DisplayObject/parent"><linktext>flash.display.DisplayObject.parent</linktext></link><link href="flash.net.xml#URLRequest/url"><linktext>flash.net.URLRequest.url</linktext></link><link href="flash.system.xml#Security/allowInsecureDomain()"><linktext>allowInsecureDomain()</linktext></link></related-links></apiOperation><apiOperation id="flash.system:Security:allowInsecureDomain"><apiName>allowInsecureDomain</apiName><shortdesc>
     Lets SWF files and HTML files in the identified domains access objects 
     and variables in the calling SWF file, which is hosted by means of the HTTPS protocol.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.allowInsecureDomain, allowInsecureDomain
     </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiException><apiDesc>Calling this method from code in the AIR application security sandbox causes a 
     SecurityError exception to be thrown. Content outside of the application security sandbox cannot cross-script
     content in the application security sandbox. 
     
     </apiDesc><apiItemName>SecurityError</apiItemName><apiOperationClassifier>SecurityError</apiOperationClassifier></apiException><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>domains</apiItemName><apiType value="restParam"/><apiDesc>One or more strings or URLRequest objects that name the domains from which
     you want to allow access.  You can specify the special domain "~~" to
     allow access from all domains.  
     
     <p class="flashonly">Specifying "~~" is the only
     way to allow access to nonlocal SWF files from local SWF files that have been
     published using the Access Network Only option for the Local Playback
     Security setting (File &gt; Publish Settings &gt; Flash tab) in the Flash authoring tool.</p>
     
     </apiDesc></apiParam><apiTipTexts><apiTipText>Lets SWF and HTML files hosted using the HTTPS protocol, access objects and variables in 
     the calling SWF file.
     
     </apiTipText></apiTipTexts></apiOperationDef><apiDesc>
     <ph platform="actionscript">Lets SWF files and HTML files in the identified domains access objects 
     and variables in the calling SWF file, which is hosted by means of the HTTPS protocol. </ph>
     
     <p platform="javascript">This method applies to cross-scripting of ActionScript 3.0 code 
     (in SWF content). It does not apply to JavaScript code running in HTML-based AIR applications.</p>
     
     
     <p platform="actionscript">Flash Player provides <codeph>allowInsecureDomain()</codeph> to maximize flexibility, 
     but calling this method is not recommended. Serving a file over HTTPS provides several protections
     for you and your users, and calling <codeph>allowInsecureDomain</codeph> weakens one of those
     protections.</p>
     
     <p platform="actionscript"><i>Note:</i> Calling this method from code in the AIR application sandbox 
     throws a SecurityError exception. Content outside of the application security domain cannot directly
     cross-script content in the application sandbox. However, content outside of the application sandbox can 
     communicate with content in the application security sandbox using a sandbox bridge.</p>
     
     <p platform="actionscript">This method works in the same way as <codeph>Security.allowDomain()</codeph>, but it also 
     permits operations in which the accessing party is loaded with a non-HTTPS protocol, and the
     party being accessed is loaded with HTTPS. In Flash Player 7 and later, 
     non-HTTPS files are not allowed to script HTTPS files. The <codeph>allowInsecureDomain()</codeph> method lifts this
     restriction when the HTTPS SWF file being accessed uses it.</p>
     
     <p platform="actionscript">Use <codeph>allowInsecureDomain()</codeph> only to enable scripting from non-HTTPS files
     to HTTPS files. Use it to enable scripting when the accessing non-HTTPS file and 
     the HTTPS file being accessed are served from the same domain, for example, if a SWF file at
     http://mysite.com wants to script a SWF file at https://mysite.com. Do not use this method to enable
     scripting between non-HTTPS files, between HTTPS files, or from HTTPS files to non-HTTPS
     files. For those situations, use <codeph>allowDomain()</codeph> instead.</p>
     
     The following scenario illustrates how <codeph>allowInsecureDomain()</codeph> can compromise security, if it is not used 
     with careful consideration.
     
     <p platform="actionscript">Note that the following information is only one possible scenario, designed to
     help you understand <codeph>allowInsecureDomain()</codeph> through a real-world example 
     of cross-scripting.
     It does not cover all issues with security architecture and should be used for background
     information only. The Flash Player Developer Center contains extensive information on Flash Player
     and security. For more information, see 
     the Flash Player Developer Center Topic <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref>.</p>
     
     <p platform="actionscript">Suppose you are building an e-commerce site that consists of two components:
     a catalog, which does not need to be secure, because it contains only public information;
     and a shopping cart/checkout component, which must be secure to protect users' financial and
     personal information. Suppose you are considering serving the catalog from 
     http://mysite.com/catalog.swf and the cart from https://mysite.com/cart.swf. One 
     requirement for your site is that a third party should not be able to steal your
     users' credit card numbers by taking advantage of a weakness in your security architecture.</p>
     
     <p platform="actionscript">Suppose that a middle-party attacker intervenes between your server and your users, attempting
     to steal the credit card numbers that your users enter into your shopping cart application. 
     A middle party might, for example, be an unscrupulous ISP used by some of your users, or a 
     malicious administrator at a user's workplace — anyone who has the ability to view or alter 
     network packets transmitted over the public Internet between your users and your servers. 
     This situation is not uncommon.</p> 
     
     <p platform="actionscript">If cart.swf uses HTTPS to transmit credit card information to your servers, then the 
     middle-party attacker can't directly steal this information from network packets, because the
     HTTPS transmission is encrypted. However, the attacker can use a different technique: altering the
     contents of one of your SWF files as it is delivered to the user, replacing your SWF file with an 
     altered version that transmits the user's information to a different server, owned by the attacker.</p>
     
     <p platform="actionscript">The HTTPS protocol, among other things, prevents this "modification" attack from working, 
     because, in addition to being encrypted, HTTPS transmissions are tamper-resistant. 
     If a middle-party attacker alters a packet, the receiving side detects the alteration 
     and discards the packet. So the attacker in this situation can't alter cart.swf, because it 
     is delivered over HTTPS.</p>
     
     <p platform="actionscript">However, suppose that you want to allow buttons in catalog.swf, served over HTTP, 
     to add items to the shopping cart in cart.swf, served over HTTPS. To accomplish this,
     cart.swf calls <codeph>allowInsecureDomain()</codeph>, which allows catalog.swf to script cart.swf. 
     This action has an unintended consequence: Now the attacker can alter  
     catalog.swf as it is initially being downloaded by
     the user, because catalog.swf is delivered with HTTP and is not tamper-resistant. 
     The attacker's altered catalog.swf can now script cart.swf, because cart.swf contains
     a call to <codeph>allowInsecureDomain()</codeph>. The altered catalog.swf file can use ActionScript to access 
     the variables in cart.swf, thus reading the user's credit card information and other
     sensitive data. The altered catalog.swf can then send this data to an attacker's server.</p>
     
     <p platform="actionscript">Obviously, this implementation is not desired, but you still want to allow
     cross-scripting between the two SWF files on your site. Here are two possible ways to redesign
     this hypothetical e-commerce site to avoid <codeph>allowInsecureDomain()</codeph>:</p>
     
     <ul platform="actionscript">
       <li>Serve all SWF files in the application over HTTPS. This is by far the simplest and most
     reliable solution. In the scenario described, you would serve both catalog.swf and cart.swf  
     over HTTPS. You might experience slightly higher bandwidth consumption and server CPU load
     when switching a file such as catalog.swf from HTTP to HTTPS, and your users might experience
     slightly longer application load times. You need to experiment with real servers to
     determine the severity of these effects; usually they are no worse than 10-20% each, and
     sometimes they are not present at all. You can usually improve results by using HTTPS-accelerating
     hardware or software on your servers. A major benefit of serving all 
     cooperating SWF files over HTTPS is that you can use an HTTPS URL as the main URL
     in the user's browser without generating any mixed-content warnings from the browser. 
     Also, the browser's padlock icon becomes visible, providing your users with
     a common and trusted indicator of security.</li>
     
      <li>Use HTTPS-to-HTTP scripting, rather than HTTP-to-HTTPS scripting. In the scenario described, you
     could store the contents of the user's shopping cart in catalog.swf, and have cart.swf manage
     only the checkout process. At checkout time, cart.swf could retrieve the cart contents from 
     ActionScript variables in catalog.swf. The restriction on HTTP-to-HTTPS scripting is asymmetrical;
     although an HTTP-delivered catalog.swf file cannot safely be allowed to script an HTTPS-delivered cart.swf file,
     an HTTPS cart.swf file can script the HTTP catalog.swf file. 
     This approach is more delicate than the all-HTTPS approach; you must be careful not to trust any
     SWF file delivered over HTTP, because of its vulnerability to tampering. For example, when cart.swf 
     retrieves the ActionScript variable that describes the cart contents, the ActionScript code 
     in cart.swf cannot trust that the value of this variable is in the format that you expect. 
     You must verify that the cart contents do not contain invalid data that might 
     lead cart.swf to take an undesired action. You must also accept the risk that a middle party,
     by altering catalog.swf, could supply valid but inaccurate data to cart.swf; for example, by placing
     items in the user's cart. The usual checkout process mitigates
     this risk somewhat by displaying the cart contents and total cost for final approval by the user,
     but the risk remains present.</li>
     </ul>
     
     <p platform="actionscript">Web browsers have enforced separation between HTTPS and non-HTTPS files for years, 
     and the scenario described illustrates one good reason for this restriction. 
     Flash Player gives you the ability to work around this security restriction when you 
     absolutely must, but be sure to consider the consequences carefully before doing so.</p>
     
     <p platform="actionscript">For more information related to security, see the following:</p>
     
     <ul platform="actionscript">
     
     <li product="flex">The <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref> in the 
     <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
     <li product="flash">The <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
       <li>The Flash Player Developer Center Topic: <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref></li>
     
     </ul>
	 
     </apiDesc></apiOperationDetail><related-links><link href="flash.system.xml#Security/allowDomain()"><linktext>allowDomain()</linktext></link></related-links></apiOperation><apiOperation id="flash.system:Security:loadPolicyFile"><apiName>loadPolicyFile</apiName><shortdesc>  
     Looks for a policy file at the location specified by the url 
     parameter.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>url</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>The URL location of the policy file to be loaded.
     </apiDesc></apiParam><apiTipTexts><apiTipText>Looks for a policy file at the location specified by the url parameter.
     
     </apiTipText></apiTipTexts></apiOperationDef><apiDesc>  
     Looks for a policy file at the location specified by the <codeph>url</codeph> 
     parameter. Adobe AIR and Flash Player use policy files to determine
      whether to permit applications to load data from servers other than their own.
     Note that even though the method name is <codeph> loadPolicyFile()</codeph>,
     the file isn't actually loaded until a network request that requires a policy file is made.
     
	 <p>With <codeph>Security.loadPolicyFile()</codeph>, Flash Player or AIR can 
     load policy files from arbitrary locations, as shown in the following example:</p>
     
     <codeblock platform="actionscript">
     Security.loadPolicyFile("http://www.example.com/sub/dir/pf.xml");
     </codeblock>
     
     <codeblock platform="javascript">
     air.Security.loadPolicyFile("http://www.example.com/sub/dir/pf.xml");
     </codeblock>
     
     <p>This causes Flash Player or AIR to attempt to retrieve a policy file from the specified URL. Any permissions 
     granted by the policy file at that location will apply to all content at the same level or lower in 
     the virtual directory hierarchy of the server. </p>
     
     <p platform="actionscript">For example, following the previous code, these lines do not throw an exception:</p>
     
     <codeblock platform="actionscript"> import flash.net.~~;
     var request:URLRequest = new URLRequest("http://www.example.com/sub/dir/vars.txt");
     var loader:URLLoader = new URLLoader();
     loader.load(request);
     
     var loader2:URLLoader = new URLLoader();
     var request2:URLRequest = new URLRequest("http://www.example.com/sub/dir/deep/vars2.txt");
     loader2.load(request2);
     </codeblock>
     
     <p platform="actionscript">However, the following code does throw a security exception:</p>
     
     <codeblock platform="actionscript"> import flash.net.~~;
     var request3:URLRequest = new URLRequest("http://www.example.com/elsewhere/vars3.txt");
     var loader3:URLLoader = new URLLoader();
     loader3.load(request3);
     </codeblock>
     
     <p>You can use <codeph>loadPolicyFile()</codeph> to load any number of policy files. When considering a 
     request that requires a policy file, Flash Player or AIR always waits for the completion of any policy 
     file downloads before denying a request. As a final fallback, if no policy file specified with 
     <codeph>loadPolicyFile()</codeph> authorizes a request, Flash Player or AIR consults the original default 
     locations.</p>
     
     <p>When checking for a master policy file, Flash Player waits three seconds for a server response.
     If a response isn't received, Flash Player assumes that no master policy file exists.
     However, there is no default timeout value for calls to <codeph>loadPolicyFile()</codeph>;
     Flash Player assumes that the file being called exists, and waits as long as necessary to load it.
     Therefore, if you want to make sure that a master policy file is loaded, use <codeph>loadPolicyFile()</codeph>
     to call it explicitly.</p>
     
      <p>You cannot load policy files that are served from commonly reserved ports. For a complete list of 
     blocked ports, see "Restricting Networking APIs" in the 
     <ph product="flex">
     <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref>
     </ph>
     <ph product="flash">
     <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
     </ph>
      of the <i>Programming ActionScript 3.0</i> book.</p>
     
     <p>Using the <codeph>xmlsocket</codeph> protocol along with a specific port number lets you retrieve 
      policy files directly from an XMLSocket server, as shown in the following example. Socket 
      connections are not subject to the reserved port restriction described above.</p>
     
     <codeblock platform="actionscript">
     Security.loadPolicyFile("xmlsocket://foo.com:414");
     </codeblock>
     
     <codeblock platform="javascript">
     air.Security.loadPolicyFile("xmlsocket://foo.com:414");
     </codeblock>
     
     <p>This causes Flash Player or AIR to attempt to retrieve a policy file from the specified host and port. 
     Upon establishing a connection with the 
     specified port, Flash Player or AIR transmits <codeph>&lt;policy-file-request /&gt;</codeph>, terminated by a 
     <codeph>null</codeph> byte.  The server must send a null byte to terminate a policy file, and may thereafter close the connection; 
     if the server does not close the connection, Flash Player or AIR does so upon receiving the terminating 
     <codeph>null</codeph> byte.</p>
     
     <p platform="actionscript">You can prevent a SWF file from using this method by setting the 
     <codeph>allowNetworking</codeph> parameter of the <codeph>object</codeph> and <codeph>embed</codeph> 
     tags in the HTML page that contains the SWF content.</p>
     
     <p>For more information related to security, see the following:</p>
     
     <ul>
     
     <li product="flex">The <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
     <li product="flash">The <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
       <li>The Flash Player Developer Center Topic: <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref></li>
     
     </ul>
     
     </apiDesc></apiOperationDetail></apiOperation><apiOperation id="flash.system:Security:showSettings"><apiName>showSettings</apiName><shortdesc>
     Displays the Security Settings panel in Flash Player.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.showSettings(), showSettings()
     </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>panel</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiData>default</apiData><apiDesc>A value from the SecurityPanel class that specifies which Security Settings
     panel you want to display. If you omit this parameter, <codeph>SecurityPanel.DEFAULT</codeph> is used. 
     
     </apiDesc></apiParam></apiOperationDef><apiDesc>
     Displays the Security Settings panel in Flash Player. This method does not apply to content in
     Adobe AIR; calling it in an AIR application has no effect.
     
     </apiDesc></apiOperationDetail><related-links><link href="flash.system.xml#SecurityPanel"><linktext>SecurityPanel</linktext></link></related-links></apiOperation><apiValue id="flash.system:Security:APPLICATION"><apiName>APPLICATION</apiName><shortdesc>
	 The file is running in an AIR application, and it was installed with the package (the AIR file) for that 
	 application.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>application</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The file is running in an AIR application, and it was installed with the package (the AIR file) for that 
	 application. This content is included in the AIR application resource directory (where the application
	 content is installed).
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/sandboxType"><linktext>sandboxType</linktext></link><link href="flash.system.xml#Security/REMOTE"><linktext>REMOTE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_FILE"><linktext>LOCAL_WITH_FILE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_NETWORK"><linktext>LOCAL_WITH_NETWORK</linktext></link><link href="flash.system.xml#Security/LOCAL_TRUSTED"><linktext>LOCAL_TRUSTED</linktext></link></related-links></apiValue><apiValue id="flash.system:Security:LOCAL_TRUSTED"><apiName>LOCAL_TRUSTED</apiName><shortdesc>
     The file is a local file and has been trusted by the user, 
     using either the Flash Player Settings Manager or a FlashPlayerTrust configuration
     file.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><refpath>
     </refpath></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>localTrusted</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     The file is a local file and has been trusted by the user, 
     using either the Flash Player Settings Manager or a FlashPlayerTrust configuration
     file. The file can read from local data sources and communicate 
     with the Internet.
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/sandboxType"><linktext>sandboxType</linktext></link><link href="flash.system.xml#Security/REMOTE"><linktext>REMOTE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_FILE"><linktext>LOCAL_WITH_FILE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_NETWORK"><linktext>LOCAL_WITH_NETWORK</linktext></link><link href="flash.system.xml#Security/APPLICATION"><linktext>APPLICATION</linktext></link></related-links></apiValue><apiValue id="flash.system:Security:LOCAL_WITH_FILE"><apiName>LOCAL_WITH_FILE</apiName><shortdesc>
     The file is a local file, has not been trusted by the user, 
	 and it is not a SWF file that was published with a networking designation.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><refpath>
     </refpath></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>localWithFile</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     The file is a local file, has not been trusted by the user, 
	 and it is not a SWF file that was published with a networking designation. In Adobe AIR,
	 the local file is <i>not</i> in the application resource directory; such files are 
	 put in the application security sandbox. The file may 
     read from local data sources but may not communicate with the Internet.
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/sandboxType"><linktext>sandboxType</linktext></link><link href="flash.system.xml#Security/REMOTE"><linktext>REMOTE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_NETWORK"><linktext>LOCAL_WITH_NETWORK</linktext></link><link href="flash.system.xml#Security/LOCAL_TRUSTED"><linktext>LOCAL_TRUSTED</linktext></link><link href="flash.system.xml#Security/APPLICATION"><linktext>APPLICATION</linktext></link></related-links></apiValue><apiValue id="flash.system:Security:LOCAL_WITH_NETWORK"><apiName>LOCAL_WITH_NETWORK</apiName><shortdesc>
	 The file is a local file, has not been trusted by the user, and it is a SWF
	 file that was published with a networking designation.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><refpath>
     </refpath></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>localWithNetwork</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The file is a local file, has not been trusted by the user, and it is a SWF
	 file that was published with a networking designation. The file can 
     communicate with the Internet but cannot read from local data sources.
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/sandboxType"><linktext>sandboxType</linktext></link><link href="flash.system.xml#Security/REMOTE"><linktext>REMOTE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_FILE"><linktext>LOCAL_WITH_FILE</linktext></link><link href="flash.system.xml#Security/LOCAL_TRUSTED"><linktext>LOCAL_TRUSTED</linktext></link><link href="flash.system.xml#Security/APPLICATION"><linktext>APPLICATION</linktext></link></related-links></apiValue><apiValue id="flash.system:Security:REMOTE"><apiName>REMOTE</apiName><shortdesc>
     The file is from an Internet URL and operates under domain-based sandbox rules.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><refpath>
     </refpath></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>remote</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     The file is from an Internet URL and operates under domain-based sandbox rules.
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/sandboxType"><linktext>sandboxType</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_FILE"><linktext>LOCAL_WITH_FILE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_NETWORK"><linktext>LOCAL_WITH_NETWORK</linktext></link><link href="flash.system.xml#Security/LOCAL_TRUSTED"><linktext>LOCAL_TRUSTED</linktext></link><link href="flash.system.xml#Security/APPLICATION"><linktext>APPLICATION</linktext></link></related-links></apiValue><apiValue id="flash.system:Security:exactSettings:get"><apiName>exactSettings</apiName><shortdesc>
     Determines how Flash Player or AIR chooses the domain to use for certain 
     content settings, including settings for camera and microphone 
     permissions, storage quotas, and storage of persistent shared objects.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.exactSettings, exactSettings
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="readwrite"/><apiValueClassifier>Boolean</apiValueClassifier><apiException><apiDesc>A Flash Player or AIR application already used the value of <codeph>exactSettings</codeph> 
     at least once in a decision about player settings.
     
     </apiDesc><apiItemName>SecurityError</apiItemName><apiOperationClassifier>SecurityError</apiOperationClassifier></apiException></apiValueDef><apiDesc>
     Determines how Flash Player or AIR chooses the domain to use for certain 
     content settings, including settings for camera and microphone 
     permissions, storage quotas, and storage of persistent shared objects.
	 To have the SWF file use the same settings that were used in Flash Player 6,
     set <codeph>exactSettings</codeph> to <codeph>false</codeph>.
     
     <p platform="javascript">This property is to be used in SWF content, not in
     JavaScript code in AIR applications.</p>
     
     <p platform="actionscript">In Flash Player 6, the domain used for these player settings was based on
     the trailing portion of the domain of the SWF file. If the domain of a SWF file
     includes more than two segments, such as www.example.com, the first segment
     of the domain ("www") is removed, and the remaining portion of the domain is used: 
     example.com. So, in Flash Player 6, www.example.com and store.example.com both 
     use example.com as the domain for these settings. Similarly, www.example.co.uk and 
     store.example.co.uk both use example.co.uk as the domain for these settings.
     In Flash Player 7 and later, player settings are chosen by default
     according to a SWF file's exact domain; for example, a SWF file from www.example.com
     would use the player settings for www.example.com, and a SWF file from
     store.example.com would use the separate player settings for
     store.example.com.</p>
     
     <p platform="actionscript">When <codeph>Security.exactSettings</codeph> is set to <codeph>true</codeph>, Flash Player uses
     exact domains for player settings.  When it is set to <codeph>false</codeph>, the
     Flash Player uses domain settings used in Flash Player 6.  The default
     value for <codeph>exactSettings</codeph> is <codeph>true</codeph>. If you change
     <codeph>exactSettings</codeph> from its default value, do so before any events
     occur that require Flash Player to choose player settings — for example, 
     using a camera or microphone, or retrieving a persistent shared object.</p>
     
     <p platform="actionscript">If you previously published a version 6 SWF file and
     created persistent shared objects from it, and you now need to
     retrieve those persistent shared objects from that SWF file
     after porting it to version 7 or later, or from a different SWF file of
     version 7 or later, set <codeph>Security.exactSettings</codeph> to <codeph>false</codeph>
     before calling <codeph>SharedObject.getLocal()</codeph>.</p>
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Security:sandboxType:get"><apiName>sandboxType</apiName><shortdesc>
     Indicates the type of security sandbox in which the calling file is operating.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     Indicates the type of security sandbox in which the calling file is operating.
     
     <p><codeph>Security.sandboxType</codeph> has one of the following values:</p>
     
     <ul>
     <li><codeph>remote</codeph> (<codeph>Security.REMOTE</codeph>)—This file is from an Internet URL and operates under domain-based sandbox
       rules.</li>
     <li><codeph>localWithFile</codeph> (<codeph>Security.LOCAL_WITH_FILE</codeph>)—This file is a local file, has not been trusted by the user, and
       it is not a SWF file that was published with a networking designation. The file may read from local data sources but may
       not communicate with the Internet.</li>
     <li><codeph>localWithNetwork</codeph> (<codeph>Security.LOCAL_WITH_NETWORK</codeph>)—This SWF file is a local file, has not been trusted by the user, and
       was published with a networking designation. The SWF file can communicate with the Internet but cannot
       read from local data sources.</li>
     <li><codeph>localTrusted</codeph> (<codeph>Security.LOCAL_TRUSTED</codeph>)—This file is a local file and has been trusted by 
       the user, using either the Flash Player Settings Manager or a FlashPlayerTrust configuration file. The file can read from local data
       sources and communicate with the Internet.</li>
     <li><codeph>application</codeph> (<codeph>Security.APPLICATION</codeph>)—This file is 
     running in an AIR application, and it was installed with the package (AIR file) for that 
     application. By default, files in the AIR application sandbox can cross-script any file from any domain
     (although files outside the AIR application sandbox may not be permitted to cross-script the AIR file).
     By default, files in the AIR application sandbox can load content and data from any domain. </li>
     
     </ul>
     
     <p>For more information related to security, see the following:</p>
     
     <ul>
     
     <li class="flexonly">The <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     <li product="flash">The <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
     in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
     
    <li>The Flash Player Developer Center Topic: <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref></li>
     
     </ul>
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/REMOTE"><linktext>REMOTE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_FILE"><linktext>LOCAL_WITH_FILE</linktext></link><link href="flash.system.xml#Security/LOCAL_WITH_NETWORK"><linktext>LOCAL_WITH_NETWORK</linktext></link><link href="flash.system.xml#Security/LOCAL_TRUSTED"><linktext>LOCAL_TRUSTED</linktext></link><link href="flash.system.xml#Security/APPLICATION"><linktext>APPLICATION</linktext></link></related-links></apiValue></apiClassifier><apiClassifier id="flash.system:LoaderContext"><apiName>LoaderContext</apiName><shortdesc>
 The LoaderContext class provides options for loading SWF files and other media by using the Loader class.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 The LoaderContext class provides options for loading SWF files and other media by using the Loader class.
 The LoaderContext class is used as the <codeph>context</codeph> parameter in the <codeph>load()</codeph> and 
 <codeph>loadBytes()</codeph> methods of the Loader class.
 
 <p>When loading SWF files with the <codeph>Loader.load()</codeph> method, you have two decisions to make:
 into which security domain the loaded SWF file should be placed, and into which application domain
 within that security domain? For more details on these choices, see the
 <codeph>applicationDomain</codeph> and <codeph>securityDomain</codeph> properties.</p>
 
 <p>When loading a SWF file with the <codeph>Loader.loadBytes()</codeph> method, you have the same
 application domain choice to make as for <codeph>Loader.load()</codeph>, but it's not
 necessary to specify a security domain, because <codeph>Loader.loadBytes()</codeph> always
 places its loaded SWF file into the security domain of the loading SWF file.</p>
 
 <p>When loading images (JPEG, GIF, or PNG) instead of SWF files, there is no need to
 specify a SecurityDomain or an application domain, because those concepts are 
 meaningful only for SWF files.  Instead, you have only one decision to make: do you need
 programmatic access to the pixels of the loaded image?  If so, see the
 <codeph>checkPolicyFile</codeph> property. If you want to apply deblocking when loading
 an image, use the JPEGLoaderContext class instead of the LoaderContext class.</p>
 
 </apiDesc></apiClassifierDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.system.xml#ApplicationDomain"><linktext>flash.system.ApplicationDomain</linktext></link><link href="flash.system.xml#JPEGLoaderContext"><linktext>flash.system.JPEGLoaderContext</linktext></link><link href="flash.system.xml#LoaderContext/applicationDomain"><linktext>flash.system.LoaderContext.applicationDomain</linktext></link><link href="flash.system.xml#LoaderContext/checkPolicyFile"><linktext>flash.system.LoaderContext.checkPolicyFile</linktext></link><link href="flash.system.xml#LoaderContext/securityDomain"><linktext>flash.system.LoaderContext.securityDomain</linktext></link><link href="flash.system.xml#SecurityDomain"><linktext>flash.system.SecurityDomain</linktext></link></related-links><apiConstructor id="flash.system:LoaderContext:LoaderContext"><apiName>LoaderContext</apiName><shortdesc>
     Creates a new LoaderContext object, with the specified settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiConstructorDetail><apiConstructorDef><apiAccess value="public"/><apiParam><apiItemName>checkPolicyFile</apiItemName><apiOperationClassifier>Boolean</apiOperationClassifier><apiData>false</apiData><apiDesc>Specifies whether a check should be made for the existence 
     of a URL policy file before loading the object.
     
     </apiDesc></apiParam><apiParam><apiItemName>applicationDomain</apiItemName><apiOperationClassifier>flash.system:ApplicationDomain</apiOperationClassifier><apiData>null</apiData><apiDesc>Specifies the ApplicationDomain object to use for a Loader object.
     
     </apiDesc></apiParam><apiParam><apiItemName>securityDomain</apiItemName><apiOperationClassifier>flash.system:SecurityDomain</apiOperationClassifier><apiData>null</apiData><apiDesc>Specifies the SecurityDomain object to use for a Loader object.
     
	 <p><i>Note:</i> Content in the air application security sandbox cannot load content from
	 other sandboxes into its SecurityDomain.</p>
     
     </apiDesc></apiParam></apiConstructorDef><apiDesc>
     Creates a new LoaderContext object, with the specified settings. For complete
     details on these settings, see the descriptions of the properties of this class.
     
     </apiDesc></apiConstructorDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.system.xml#ApplicationDomain"><linktext>flash.system.ApplicationDomain</linktext></link><link href="flash.system.xml#SecurityDomain"><linktext>flash.system.SecurityDomain</linktext></link></related-links></apiConstructor><apiValue id="flash.system:LoaderContext:allowLoadBytesCodeExecution"><apiName>allowLoadBytesCodeExecution</apiName><shortdesc>
	 Specifies whether you can use the loadBytes() method of a Loader object 
	 to load content with executable code, such as a SWF file.</shortdesc><prolog><asMetadata><apiVersion><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiData>false</apiData><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether you can use the <codeph>loadBytes()</codeph> method of a Loader object 
	 to load content with executable code, such as a SWF file. With his property set to <codeph>false</codeph>
	 (the default), the <codeph>loadBytes()</codeph> method is restricted to safe operations, such as loading images.
 	 
	 <p>In AIR content in the application sandbox, the default value is <codeph>false</codeph>. In non-application content, the
	 default value is <codeph>true</codeph>.</p>
	 
	 <p><b>Note:</b> This API is likely to be replaced in a future release of AIR. When that occurs, you will 
	 need to be adjust code to use the new API and recompile before destributing an application for the new version of AIR.</p>
	 
     </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link></related-links></apiValue><apiValue id="flash.system:LoaderContext:applicationDomain"><apiName>applicationDomain</apiName><shortdesc>
	 Specifies the application domain to use for the Loader.load() or
	 Loader.loadBytes() method.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiData>null</apiData><apiValueClassifier>flash.system:ApplicationDomain</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the application domain to use for the <codeph>Loader.load()</codeph> or
	 <codeph>Loader.loadBytes()</codeph> method.  Use this property only when loading a SWF file
	 written in ActionScript 3.0 (not an image or a SWF file written in ActionScript 1.0 or ActionScript 2.0).
	 
	 <p>Every security domain is divided into one or more application domains, represented
	 by ApplicationDomain objects.  Application domains are not for security
	 purposes; they are for managing cooperating units of ActionScript code.  If you are
	 loading a SWF file from another domain, and allowing it to be placed in a separate
	 security domain, then you cannot control the choice of application domain into which the
	 loaded SWF file is placed; and if you have specified a choice of application domain, it
     will be ignored.  However, if you are loading a SWF file into your own security domain —
	 either because the SWF file comes from your own domain, or because you are importing it into
     your security domain — then you can control the choice of application domain for the
	 loaded SWF file.</p>
	 
	 <p>You can pass an application domain only from your own security domain in
	 <codeph>LoaderContext.applicationDomain</codeph>.  Attempting to pass an application domain
	 from any other security domain results in a <codeph>SecurityError</codeph> exception.</p>
	 
	 <p>You have four choices for what kind of <codeph>ApplicationDomain</codeph> property to use:</p>
	 
	 <ul>
	 <li><b>Child of loader's ApplicationDomain.</b> The default. You can
	 explicitly represent this choice with the syntax
	 <codeph>new ApplicationDomain(ApplicationDomain.currentDomain)</codeph>. This allows the
	 loaded SWF file to use the parent's classes directly, for example by writing
	 <codeph>new MyClassDefinedInParent()</codeph>.  The parent, however, cannot use this syntax;
	 if the parent wishes to use the child's classes, it must call
	 <codeph>ApplicationDomain.getDefinition()</codeph> to retrieve them.  The advantage of
	 this choice is that, if the child defines a class with the same name as a class already
	 defined by the parent, no error results; the child simply inherits the parent's
	 definition of that class, and the child's conflicting definition goes unused unless
	 either child or parent calls the <codeph>ApplicationDomain.getDefinition()</codeph> method to retrieve
	 it.</li>
	 
	 <li><b>Loader's own ApplicationDomain.</b> You use this application domain when using
	 <codeph>ApplicationDomain.currentDomain</codeph>. When the load is complete, parent and
     child can use each other's classes directly. If the child attempts to define a class with the same name
     as a class already defined by the parent, the parent class is used and the child class is ignored.</li>
	 
	 <li><b>Child of the system ApplicationDomain.</b>  You use this application domain when using
	 <codeph>new ApplicationDomain(null)</codeph>.  This separates loader and loadee entirely,
	 allowing them to define separate versions of classes with the same name without conflict
	 or overshadowing.  The only way either side sees the other's classes is by calling the 
	 <codeph>ApplicationDomain.getDefinition()</codeph> method.</li>
	 
	 <li><b>Child of some other ApplicationDomain.</b>  Occasionally you may have
	 a more complex ApplicationDomain hierarchy.  You can load a SWF file into any
	 ApplicationDomain from your own SecurityDomain.  For example,
	 <codeph>new ApplicationDomain(ApplicationDomain.currentDomain.parentDomain.parentDomain)</codeph>
	 loads a SWF file into a new child of the current domain's parent's parent.</li>
	 </ul>
	 
	 <p>When a load is complete, either side (loading or loaded) may need to find its own
	 ApplicationDomain, or the other side's ApplicationDomain, for the purpose of calling
	 <codeph>ApplicationDomain.getDefinition()</codeph>.  Either side can retrieve a reference to
	 its own application domain by using <codeph>ApplicationDomain.currentDomain</codeph>.  The loading
	 SWF file can retrieve a reference to the loaded SWF file's ApplicationDomain via
	 <codeph>Loader.contentLoaderInfo.applicationDomain</codeph>.  If the loaded SWF file knows how it
	 was loaded, it can find its way to the loading SWF file's ApplicationDomain object.  For example, if
	 the child was loaded in the default way, it can find the loading SWF file's application domain
	 by using <codeph>ApplicationDomain.currentDomain.parentDomain</codeph>.</p>
	 
	 <p>For more information, see the "ApplicationDomain class" section of the "Client System
	 Environment" chapter of <i>Programming ActionScript 3.0</i>.</p>
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.system.xml#ApplicationDomain"><linktext>flash.system.ApplicationDomain</linktext></link></related-links></apiValue><apiValue id="flash.system:LoaderContext:checkPolicyFile"><apiName>checkPolicyFile</apiName><shortdesc>
	 Specifies whether the application should attempt to download a URL policy file from the
	 loaded object's server before beginning to load the object itself.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiData>false</apiData><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the application should attempt to download a URL policy file from the
	 loaded object's server before beginning to load the object itself.  This flag is applicable to
	 the <codeph>Loader.load()</codeph> method, but not to the <codeph>Loader.loadBytes()</codeph> method.
	 
	 <p>Set this flag to <codeph>true</codeph> when you are loading an image (JPEG, GIF, or PNG) from outside the calling
	 SWF file's own domain, and you expect to need access to the content of that image from ActionScript.
	 Examples of accessing image content include referencing the <codeph>Loader.content</codeph> property
	 to obtain a Bitmap object, and calling the <codeph>BitmapData.draw()</codeph> method to obtain a
	 copy of the loaded image's pixels.  If you attempt one of these operations without having
	 specified <codeph>checkPolicyFile</codeph> at loading time, you may get a <codeph>SecurityError</codeph>
	 exception because the needed policy file has not been downloaded yet.</p>
	 
	 <p>When you call the <codeph>Loader.load()</codeph> method with <codeph>LoaderContext.checkPolicyFile</codeph> set to
	 <codeph>true</codeph>, the application does not begin downloading the specified object in <codeph>URLRequest.url</codeph>
	 until it has either successfully downloaded a relevant URL policy file or discovered
	 that no such policy file exists. Flash Player or AIR first considers policy files that have already
	 been downloaded, then attempts to download any pending policy files specified in calls to
	 the <codeph>Security.loadPolicyFile()</codeph> method, then attempts to download a policy file from the default
	 location that corresponds to <codeph>URLRequest.url</codeph>, which is <codeph>/crossdomain.xml</codeph>
	 on the same server as <codeph>URLRequest.url</codeph>. In all cases, the given policy file is required to exist 
	 at <codeph>URLRequest.url</codeph> by virtue of the policy file's location, and the file must permit access
	 by virtue of one or more <codeph>&lt;allow-access-from&gt;</codeph>
	 tags.</p>
	 
	 <p>If you set <codeph>checkPolicyFile</codeph> to <codeph>true</codeph>, the main download that specified in the 
     <codeph>Loader.load()</codeph> method does not load until the policy file has been completely processed.
	 Therefore, as long as the
	 policy file that you need exists, as soon as you have received any <codeph>ProgressEvent.PROGRESS</codeph> or
	 <codeph>Event.COMPLETE</codeph> events from the <codeph>contentLoaderInfo</codeph> property of your Loader object,
	 the policy file download is complete, and you can safely begin performing operations that require
	 the policy file.</p>
	 
	 <p>If you set <codeph>checkPolicyFile</codeph> to <codeph>true</codeph>, and no relevant policy file is found, 
	 you will not receive any error indication until you attempt an operation that throws a
	 <codeph>SecurityError</codeph> exception.  However, once the LoaderInfo object dispatches a 
     <codeph>ProgressEvent.PROGRESS</codeph> or <codeph>Event.COMPLETE</codeph> event, you can test whether a relevant 
     policy file was found by checking the value of the <codeph>LoaderInfo.childAllowsParent</codeph> property.</p>
	 
	 <p>If you will not need pixel-level access to the image that you are loading, you should not set the 
     <codeph>checkPolicyFile</codeph> property to <codeph>true</codeph>.  Checking for a policy file in this case is 
     wasteful, because it may delay the start of your download, and it may consume network bandwidth unnecessarily.</p>
	 
	 <p>Also try to avoid setting <codeph>checkPolicyFile</codeph> to <codeph>true</codeph> if you are using the 
	 <codeph>Loader.load()</codeph> method to download a SWF file.  This is because SWF-to-SWF permissions are not
	 controlled by policy files, but rather by the <codeph>Security.allowDomain()</codeph> method, and thus
	 <codeph>checkPolicyFile</codeph> has no effect when you load a SWF file.  Checking for a policy file in
	 this case is wasteful, because it may delay the download of the SWF file, and it may consume
	 network bandwidth unnecessarily. (Flash Player or AIR cannot tell whether your main download will be a
	 SWF file or an image, because the policy file download occurs before the main download.)</p>
	 
	 <p>Be careful with <codeph>checkPolicyFile</codeph> if you are downloading an object from a URL that
	 may use server-side HTTP redirects. Policy files are always retrieved from the corresponding initial 
	 URL that you specify in <codeph>URLRequest.url</codeph>. If the final
	 object comes from a different URL because of HTTP redirects, then the initially downloaded policy
	 files might not be applicable to the object's final URL, which is the URL that matters in
	 security decisions.  If you find yourself in this situation, you can examine the value of 
     <codeph>LoaderInfo.url</codeph> after you have received a <codeph>ProgressEvent.PROGRESS</codeph>
	 or <codeph>Event.COMPLETE</codeph> event, which tells you the object's final URL. Then call the
	 <codeph>Security.loadPolicyFile()</codeph> method with a policy file URL based on the object's final 
     URL. Then poll the value of <codeph>LoaderInfo.childAllowsParent</codeph> until it becomes <codeph>true</codeph>.</p>
	 
     	 <p>You do not need to set this property for AIR content running in the application sandbox. Content
     	 in the AIR application sandbox can call the <codeph>BitmapData.draw()</codeph> method using any loaded image 
     	 content as the source. </p>
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#BitmapData/draw()"><linktext>flash.display.BitmapData.draw()</linktext></link><link href="flash.display.xml#Loader/content"><linktext>flash.display.Loader.content</linktext></link><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#LoaderInfo/childAllowsParent"><linktext>flash.display.LoaderInfo.childAllowsParent</linktext></link><link href="flash.display.xml#LoaderInfo/url"><linktext>flash.display.LoaderInfo.url</linktext></link><link href="flash.system.xml#Security/allowDomain()"><linktext>flash.system.Security.allowDomain()</linktext></link><link href="flash.system.xml#Security/loadPolicyFile()"><linktext>flash.system.Security.loadPolicyFile()</linktext></link></related-links></apiValue><apiValue id="flash.system:LoaderContext:securityDomain"><apiName>securityDomain</apiName><shortdesc>
	 Specifies the security domain to use for a Loader.load() operation.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiData>null</apiData><apiValueClassifier>flash.system:SecurityDomain</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the security domain to use for a <codeph>Loader.load()</codeph> operation. Use this property
 	 only when loading a SWF file (not an image).
	 
 	 <p>The choice of security domain is meaningful only if you are loading a SWF file that might
	 come from a different domain (a different server) than the loading SWF file.  When you load a
	 SWF file from your own domain, it is always placed into your security domain.  But when you
	 load a SWF file from a different domain, you have two options.  You can allow the loaded SWF file to
	 be placed in its "natural" security domain, which is different from that of the
	 loading SWF file; this is the default.  The other option is to specify that you want to place the
	 loaded SWF file placed into the same security domain as the loading SWF file, by setting
	 <codeph>myLoaderContext.securityDomain</codeph> to be equal to <codeph>SecurityDomain.currentDomain</codeph>.  This is
	 called <i>import loading</i>, and it is equivalent, for security purposes, to copying the
	 loaded SWF file to your own server and loading it from there.  In order for import loading to
	 succeed, the loaded SWF file's server must have a policy file trusting the domain of the
	 loading SWF file.</p>
	 
	 <p>You can pass your own security domain only in <codeph>LoaderContext.securityDomain</codeph>.
	 Attempting to pass any other security domain results in a <codeph>SecurityError</codeph> exception.</p>
	 
	 <p>Content in the air application security sandbox cannot load content from
	 other sandboxes into its SecurityDomain.</p>
     
	 <p>For more information, see the "Security" chapter in <i>Programming ActionScript 3.0</i>.</p>
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.system.xml#SecurityDomain"><linktext>flash.system.SecurityDomain</linktext></link></related-links></apiValue></apiClassifier><apiClassifier id="flash.system:IMEConversionMode"><apiName>IMEConversionMode</apiName><shortdesc>
 This class contains constants for use with the IME.conversionMode
 property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 This class contains constants for use with the <codeph>IME.conversionMode</codeph>
 property. Setting <codeph>conversionMode</codeph> to either 
 <codeph>ALPHANUMERIC_FULL</codeph> or <codeph>JAPANESE_KATAKANA_FULL</codeph> causes the
 player to use a full width font, whereas using <codeph>ALPHANUMERIC_HALF</codeph> or
 <codeph>JAPANESE_KATAKANA_HALF</codeph> uses a half width font.
 </apiDesc></apiClassifierDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links><apiValue id="flash.system:IMEConversionMode:ALPHANUMERIC_FULL"><apiName>ALPHANUMERIC_FULL</apiName><shortdesc>
	 The string "ALPHANUMERIC_FULL", for use with the  
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>ALPHANUMERIC_FULL</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"ALPHANUMERIC_FULL"</codeph>, for use with the  
	 <codeph>IME.conversionMode</codeph> property.
	 This constant is used with all IMEs.
	 Use the syntax <codeph>IMEConversionMode.ALPHANUMERIC_FULL</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:ALPHANUMERIC_HALF"><apiName>ALPHANUMERIC_HALF</apiName><shortdesc>
	 The string "ALPHANUMERIC_HALF", for use with the 
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>ALPHANUMERIC_HALF</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"ALPHANUMERIC_HALF"</codeph>, for use with the 
	 <codeph>IME.conversionMode</codeph> property.
	 This constant is used with all IMEs.
	 Use the syntax <codeph>IMEConversionMode.ALPHANUMERIC_HALF</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:CHINESE"><apiName>CHINESE</apiName><shortdesc>
	 The string "CHINESE", for use with the 
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>CHINESE</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"CHINESE"</codeph>, for use with the 
	 <codeph>IME.conversionMode</codeph> property.
	 This constant is used with simplified and traditional Chinese IMEs.
	 Use the syntax <codeph>IMEConversionMode.CHINESE</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:JAPANESE_HIRAGANA"><apiName>JAPANESE_HIRAGANA</apiName><shortdesc>
	 The string "JAPANESE_HIRAGANA", for use with the
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>JAPANESE_HIRAGANA</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"JAPANESE_HIRAGANA"</codeph>, for use with the
	 <codeph>IME.conversionMode</codeph> property. 
	 This constant is used with Japanese IMEs.
	 Use the syntax <codeph>IMEConversionMode.JAPANESE_HIRAGANA</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:JAPANESE_KATAKANA_FULL"><apiName>JAPANESE_KATAKANA_FULL</apiName><shortdesc>
	 The string "JAPANESE_KATAKANA_FULL", for use with the 
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>JAPANESE_KATAKANA_FULL</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"JAPANESE_KATAKANA_FULL"</codeph>, for use with the 
	 <codeph>IME.conversionMode</codeph> property.
	 This constant is used with Japanese IMEs.
	 Use the syntax <codeph>IMEConversionMode.JAPANESE_KATAKANA_FULL</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:JAPANESE_KATAKANA_HALF"><apiName>JAPANESE_KATAKANA_HALF</apiName><shortdesc>
	 The string "JAPANESE_KATAKANA_HALF", for use with the 
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>JAPANESE_KATAKANA_HALF</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"JAPANESE_KATAKANA_HALF"</codeph>, for use with the 
	 <codeph>IME.conversionMode</codeph> property. 
	 This constant is used with Japanese IMEs.
	 Use the syntax <codeph>IMEConversionMode.JAPANESE_KATAKANA_HALF</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:KOREAN"><apiName>KOREAN</apiName><shortdesc>
	 The string "KOREAN", for use with the 
	 IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>KOREAN</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"KOREAN"</codeph>, for use with the 
	 <codeph>IME.conversionMode</codeph> property.
	 This constant is used with Korean IMEs.
	 Use the syntax <codeph>IMEConversionMode.KOREAN</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:IMEConversionMode:UNKNOWN"><apiName>UNKNOWN</apiName><shortdesc>
	 The string "UNKNOWN", which can be returned by a call to
	 the IME.conversionMode property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>UNKNOWN</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 The string <codeph>"UNKNOWN"</codeph>, which can be returned by a call to
	 the <codeph>IME.conversionMode</codeph> property. This value cannot be set, 
	 and is returned only if the player is unable to identify the currently 
	 active IME.
	 Use the syntax <codeph>IMEConversionMode.UNKNOWN</codeph>.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME/conversionMode"><linktext>flash.system.IME.conversionMode</linktext></link></related-links></apiValue></apiClassifier><apiClassifier id="flash.system:SecurityPanel"><apiName>SecurityPanel</apiName><shortdesc>
 The SecurityPanel class provides values for specifying
 which Security Settings panel you want to display.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 The SecurityPanel class provides values for specifying
 which Security Settings panel you want to display.
 
 <p>This class contains static constants that are used with the 
 <codeph>Security.showSettings()</codeph> method. You cannot create new instances
 of the SecurityPanel class.</p>
 
 </apiDesc><example conref="examples\SecurityExample.as"> The following example shows how a <codeph>click</codeph> event on a Sprite object can be
 used to show the Local Storage Settings panel of the Flash Player Settings.  An orange box is added to the 
 stage using <codeph>draw()</codeph>.  In <codeph>draw()</codeph>, a <codeph>click</codeph> event listener is 
 added named <codeph>clickHandler()</codeph>, which responds to <codeph>click</codeph> events by directing
 Flash Player to open its Local Storage Settings panel.
<codeblock>
package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.events.*;
    import flash.system.Security;
    import flash.system.SecurityPanel;

    public class SecurityExample extends Sprite {
        private var bgColor:uint = 0xFFCC00;
        private var size:uint = 100;

        public function SecurityExample() {
            draw();
        }

        private function draw():void {
            var child:Sprite = new Sprite();
            child.graphics.beginFill(bgColor);
            child.graphics.drawRect(0, 0, size, size);
            child.graphics.endFill();
            child.buttonMode = true;

            var label:TextField = new TextField();
            label.text = "settings";
            label.selectable = false;
            label.mouseEnabled = false;
            child.addChild(label);

            child.addEventListener(MouseEvent.CLICK, clickHandler);
            addChild(child);
        }

        private function clickHandler(event:MouseEvent):void {
            Security.showSettings(SecurityPanel.LOCAL_STORAGE);
        }
    }
}
</codeblock></example></apiClassifierDetail><apiValue id="flash.system:SecurityPanel:CAMERA"><apiName>CAMERA</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Camera panel in Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.CAMERA, CAMERA
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>camera</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Camera panel in Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:DEFAULT"><apiName>DEFAULT</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the panel
	 that was open the last time the user closed the Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.DEFAULT, DEFAULT
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>default</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the panel
	 that was open the last time the user closed the Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:DISPLAY"><apiName>DISPLAY</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Display panel in Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.DISPLAY, DISPLAY
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>display</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Display panel in Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:LOCAL_STORAGE"><apiName>LOCAL_STORAGE</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Local Storage Settings panel in Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.LOCAL_STORAGE, LOCAL_STORAGE
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>localStorage</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Local Storage Settings panel in Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:MICROPHONE"><apiName>MICROPHONE</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Microphone panel in Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.MICROPHONE, MICROPHONE
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>microphone</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Microphone panel in Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:PRIVACY"><apiName>PRIVACY</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Privacy Settings panel in Flash Player Settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.PRIVACY, PRIVACY
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>privacy</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Privacy Settings panel in Flash Player Settings.
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:SecurityPanel:SETTINGS_MANAGER"><apiName>SETTINGS_MANAGER</apiName><shortdesc>
	 When passed to Security.showSettings(), displays the
	 Settings Manager (in a separate browser window).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>Security, Security.SETTINGS_MANAGER, SETTINGS_MANAGER
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiAccess value="public"/><apiStatic/><apiData>settingsManager</apiData><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 When passed to <codeph>Security.showSettings()</codeph>, displays the
	 Settings Manager (in a separate browser window).
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue></apiClassifier><apiClassifier id="flash.system:JPEGLoaderContext"><apiName>JPEGLoaderContext</apiName><shortdesc>
 The JPEGLoaderContext class includes a property for enabling a deblocking filter when loading a JPEG image.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiBaseClassifier>flash.system:LoaderContext</apiBaseClassifier></apiClassifierDef><apiDesc>
 The JPEGLoaderContext class includes a property for enabling a deblocking filter when loading a JPEG image. 
 The deblocking filter improves an image's quality at higher compression settings by smoothing neighboring pixels.
 To apply deblocking when loading a JPEG image, create a JPEGLoaderContext object, and set its 
 <codeph>deblockingFilter</codeph> property. Then use the JPEGLoaderContext object name as the value of the 
 <codeph>context</codeph> parameter of the <codeph>load()</codeph> method of the Loader object used to load the image.
 
 <p>The JPEGLoaderContext class extends the LoaderContext class. Set the <codeph>checkPolicyFile</codeph>
 property to <codeph>true</codeph> if you need programmatic access to the pixels of the loaded image 
 (for example, if you're using the <codeph>BitmapData.draw()</codeph> method). Setting the <codeph>checkPolicyFile</codeph> 
 property is not necessary for AIR content running in the application sandbox.</p>
 
 </apiDesc></apiClassifierDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#BitmapData/draw()"><linktext>flash.display.BitmapData.draw()</linktext></link></related-links><apiConstructor id="flash.system:JPEGLoaderContext:JPEGLoaderContext"><apiName>JPEGLoaderContext</apiName><shortdesc>
     Creates a new JPEGLoaderContext object with the specified settings.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata></prolog><apiConstructorDetail><apiConstructorDef><apiAccess value="public"/><apiParam><apiItemName>deblockingFilter</apiItemName><apiOperationClassifier>Number</apiOperationClassifier><apiData>0.0</apiData><apiDesc>Specifies the strength of the deblocking filter. A value of 1.0 
     applies a full strength deblocking filter, a value of 0.0 disables the deblocking filter.
     
     </apiDesc></apiParam><apiParam><apiItemName>checkPolicyFile</apiItemName><apiOperationClassifier>Boolean</apiOperationClassifier><apiData>false</apiData><apiDesc>Specifies whether Flash Player should check for the existence 
     of a URL policy file before loading the object.
     
     </apiDesc></apiParam><apiParam><apiItemName>applicationDomain</apiItemName><apiOperationClassifier>flash.system:ApplicationDomain</apiOperationClassifier><apiData>null</apiData><apiDesc>Specifies the ApplicationDomain object to use for a Loader object.
     
     </apiDesc></apiParam><apiParam><apiItemName>securityDomain</apiItemName><apiOperationClassifier>flash.system:SecurityDomain</apiOperationClassifier><apiData>null</apiData><apiDesc>Specifies the SecurityDomain object to use for a Loader object.
     
     </apiDesc></apiParam></apiConstructorDef><apiDesc>
     Creates a new JPEGLoaderContext object with the specified settings. 
     
     </apiDesc></apiConstructorDetail><related-links><link href="flash.system.xml#LoaderContext"><linktext>flash.system.LoaderContext</linktext></link><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.system.xml#ApplicationDomain"><linktext>flash.system.ApplicationDomain</linktext></link><link href="flash.system.xml#SecurityDomain"><linktext>flash.system.SecurityDomain</linktext></link></related-links></apiConstructor><apiValue id="flash.system:JPEGLoaderContext:deblockingFilter"><apiName>deblockingFilter</apiName><shortdesc> 
	 Specifies the strength of the deblocking filter.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiData>0.0</apiData><apiValueClassifier>Number</apiValueClassifier></apiValueDef><apiDesc> 
	 Specifies the strength of the deblocking filter. A value of 1.0 
	 applies a full strength deblocking filter, a value of 0.0 disables the deblocking filter.
	 
	 </apiDesc></apiValueDetail></apiValue></apiClassifier><apiClassifier id="flash.system:ApplicationDomain"><apiName>ApplicationDomain</apiName><shortdesc>
 The ApplicationDomain class is a container for discrete groups of class definitions.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><internal>Security considerations for application domains are discussed in the 
 applicationDomain property entries of URLRequest and LoaderInfo. 
 
 </internal></asCustoms></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 The ApplicationDomain class is a container for discrete groups of class definitions.
 Application domains are used to partition classes that are in the same security domain. 
 They allow multiple definitions of the same class to exist and allow children to reuse parent
 definitions.
 
 <p>Application domains are used when an external SWF file is loaded through the Loader class.
 All ActionScript 3.0 definitions in the loaded SWF file are stored in the application
 domain, which is specified by the <codeph>applicationDomain</codeph> property of the LoaderContext 
 object that you pass as a <codeph>context</codeph> parameter of the Loader object's <codeph>load()</codeph> or 
 <codeph>loadBytes()</codeph> method. The LoaderInfo object also contains an
 <codeph>applicationDomain</codeph> property, which is read-only.</p>
 
 <p>All code in a SWF file is defined to exist in an application domain. The current application 
 domain is where your main application runs. The system domain contains all application domains,
 including the current domain, which means that it contains all Flash Player classes.</p>
 
 <p>Every application domain, except the system domain, has an associated parent domain. 
 The parent domain of your main application's application domain is the system domain. 
 Loaded classes are defined only when their parent doesn't already define them. 
 You cannot override a loaded class definition with a newer definition.</p>
 
 <p>For usage examples of application domains, see <i>Programming ActionScript 3.0</i>.</p>
 
 <p>The <codeph>ApplicationDomain()</codeph> constructor function allows you to create an ApplicationDomain object.</p>
 
 </apiDesc><example conref="examples\ApplicationDomainExample.as"> The following example demonstrates runtime class loading as well as how to call public methods of a class that reside in another SWF.
 <p><b>Notes:</b></p>
 <ul>
    <li>Since the ClassLoader class loads a SWF file, local security needs to be at the file system level.</li>
    <li>To run this example, you must have a swf file called RuntimeClasses.swf existing in the same folder 
        as the ApplicationDomainExample.swf file.</li>
 </ul>
 
 <p>Begin by creating the RuntimeClasses.swf file from the following code:</p>
 <codeblock platform="actionscript">
 package {
   import flash.display.Sprite;
   public class RuntimeClasses extends Sprite
   {
     public function RuntimeClasses()
     {}
      
     public function greet():String {
       return("Hello World");
     }
   }
 }
 </codeblock>
 
 <p>Then implement the following code:</p>
<codeblock>

package {
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.errors.IllegalOperationError;
    import flash.events.Event;
    import flash.text.TextField;

    public class ApplicationDomainExample extends Sprite {
        private var loader:ClassLoader;
        private var tf:TextField = new TextField();

        public function ApplicationDomainExample() {
            addChild(tf);

            loader = new ClassLoader();
            loader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            loader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            loader.load("RuntimeClasses.swf");
        }

        private function loadErrorHandler(e:Event):void {
            tf.text = "Load failed";
            throw new IllegalOperationError("Cannot load the specified file.");
        }

        private function classLoadedHandler(e:Event):void {
            var runtimeClassRef:Class = loader.getClass("RuntimeClasses");
            var greeter:Object = new runtimeClassRef();

            tf.text = greeter.greet();
        }
    }
}

import flash.display.Loader;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;

class ClassLoader extends EventDispatcher {
    public static var CLASS_LOADED:String = "classLoaded";
    public static var LOAD_ERROR:String = "loadError";
    private var loader:Loader;
    private var swfLib:String;
    private var request:URLRequest;
    private var loadedClass:Class;

    public function ClassLoader() {

        loader = new Loader();
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
        loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
    }

    public function load(lib:String):void {
        swfLib = lib;
        request = new URLRequest(swfLib);
        var context:LoaderContext = new LoaderContext();
        context.applicationDomain=ApplicationDomain.currentDomain;
        loader.load(request,context);
    }

    public function getClass(className:String):Class {
        try {
            return loader.contentLoaderInfo.applicationDomain.getDefinition(className)  as  Class;
        } catch (e:Error) {
            throw new IllegalOperationError(className + " definition not found in " + swfLib);
        }
        return null;
    }

    private function completeHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.CLASS_LOADED));
    }

    private function ioErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }

    private function securityErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }
}
</codeblock></example><example conref="examples\ApplicationDomainExample.2.as"> If multiple SWF files contain compiled classes with the same name but provide different implementation, you can partition the classes of externally loaded SWF files separate from the classes of each other following this example.
 Previously, the child SWF was instructed to use <codeph>ApplicationDomain.currentDomain</codeph>. In this case, a new <codeph>ApplicationDomain</codeph> is created,
 so that then the properties and methods of the <codeph>Greeter</codeph> class of whichever SWF loads second will not replace the properties and methods of the first <codeph>Greeter</codeph> class.
 You can test this by modifying the <codeph>context.applicationDomain</codeph> property in the <codeph>load</codeph> method of <codeph>ClassLoader</codeph>.
 <p><b>Notes:</b></p>
 <ul>
    <li>Since the ClassLoader class loads a SWF file, local security needs to be at the file system level.</li>
    <li>To run this example, you must have two SWF files called Greeter.swf existing in an "en" and "es" folder respectively.</li>
 </ul>
 
 <p>Create a Greeter.as file in the "en" directory with the following code:</p>
 <codeblock platform="actionscript">
 package {
    import flash.display.Sprite;
    public class Greeter extends Sprite
    {
        public function Greeter()
        {
        }
        
        public function greet():String {
            return("Good Morning");
        }
    }
 }
 </codeblock>
 <p>Then create a very similar Greeter.as file in the "es" directory:</p>
 
 <codeblock platform="actionscript">
 package {
    import flash.display.Sprite;
    public class Greeter extends Sprite
    {
        public function Greeter()
        {
        }
        
        public function greet():String {
            return("Buenos Dias");
        }
    }
}
 </codeblock>
 
 <p>Compile SWF files for both and then implement the following code:</p>
<codeblock>
package {
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.errors.IllegalOperationError;
    import flash.events.Event;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;

    public class ApplicationDomainExample2 extends Sprite {
        private var spanishGreeterLoader:ClassLoader;
        private var englishGreeterLoader:ClassLoader;
        private var tf:TextField = new TextField();
        private var greetersLoaded:uint = 0;

        public function ApplicationDomainExample2() {
            tf.autoSize = TextFieldAutoSize.LEFT;
            addChild(tf);

            spanishGreeterLoader = new ClassLoader();
            spanishGreeterLoader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            spanishGreeterLoader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            spanishGreeterLoader.load("es/Greeter.swf");
            
            englishGreeterLoader = new ClassLoader();
            englishGreeterLoader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            englishGreeterLoader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            englishGreeterLoader.load("en/Greeter.swf");
        }

        private function loadErrorHandler(e:Event):void {
            tf.text = "Load failed";
            throw new IllegalOperationError("Cannot load the specified file.");
        }

        private function classLoadedHandler(e:Event):void {
            greetersLoaded++;
            if(greetersLoaded == 2) {
                greet();    
            }
        }
        
        private function greet():void {
            var spanishGreeter:Class = spanishGreeterLoader.getClass("Greeter");
            var englishGreeter:Class = englishGreeterLoader.getClass("Greeter");
            var greeter1 = new spanishGreeter();
            var greeter2 = new englishGreeter();
            
            tf.text = greeter1.greet() + "\n" + greeter2.greet();
        }
    }
}

import flash.display.Loader;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;

class ClassLoader extends EventDispatcher {
    public static var CLASS_LOADED:String = "classLoaded";
    public static var LOAD_ERROR:String = "loadError";
    private var loader:Loader;
    private var swfLib:String;
    private var request:URLRequest;
    private var loadedClass:Class;

    public function ClassLoader() {

        loader = new Loader();
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
        loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
    }

    public function load(lib:String):void {
        swfLib = lib;
        request = new URLRequest(swfLib);
        var context:LoaderContext = new LoaderContext();
//        context.applicationDomain = ApplicationDomain.currentDomain;
        context.applicationDomain = new ApplicationDomain();
        loader.load(request,context);
    }

    public function getClass(className:String):Class {
        try {
            return loader.contentLoaderInfo.applicationDomain.getDefinition(className)  as  Class;
        } catch (e:Error) {
            throw new IllegalOperationError(className + " definition not found in " + swfLib);
        }
        return null;
    }

    private function completeHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.CLASS_LOADED));
    }

    private function ioErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }

    private function securityErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }
}
</codeblock></example></apiClassifierDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.display.xml#LoaderInfo"><linktext>flash.display.LoaderInfo</linktext></link><link href="flash.net.xml#URLRequest"><linktext>flash.net.URLRequest</linktext></link><link href="flash.system.xml#LoaderContext"><linktext>flash.system.LoaderContext</linktext></link></related-links><apiConstructor id="flash.system:ApplicationDomain:ApplicationDomain"><apiName>ApplicationDomain</apiName><shortdesc>
     Creates a new application domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata></prolog><apiConstructorDetail><apiConstructorDef><apiAccess value="public"/><apiParam><apiItemName>parentDomain</apiItemName><apiOperationClassifier>flash.system:ApplicationDomain</apiOperationClassifier><apiData>null</apiData><apiDesc>If no parent domain is passed in, this application domain takes the system domain as its parent.
     
	 </apiDesc></apiParam></apiConstructorDef><apiDesc>
     Creates a new application domain.
     
     </apiDesc></apiConstructorDetail></apiConstructor><apiOperation id="flash.system:ApplicationDomain:getDefinition"><apiName>getDefinition</apiName><shortdesc>
     Gets a public definition from the specified application domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><internal>throws SecurityError The definition belongs to a domain to which
     the calling code does not have access.
     
	 </internal></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiException><apiDesc>No public definition exists with the
     specified name.
     
     </apiDesc><apiItemName>ReferenceError</apiItemName><apiOperationClassifier>ReferenceError</apiOperationClassifier></apiException><apiReturn><apiDesc>The object associated with the definition.
     
     </apiDesc><apiOperationClassifier>Object</apiOperationClassifier></apiReturn><apiParam><apiItemName>name</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>The name of the definition.
     </apiDesc></apiParam></apiOperationDef><apiDesc>
     Gets a public definition from the specified application domain.
     The definition can be that of a class, a namespace, or a function.
     
     </apiDesc></apiOperationDetail></apiOperation><apiOperation id="flash.system:ApplicationDomain:hasDefinition"><apiName>hasDefinition</apiName><shortdesc>
     Checks to see if a public definition exists within the specified application domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiReturn><apiDesc>A value of <codeph>true</codeph> if the specified definition exists; otherwise, <codeph>false</codeph>.
     
	 </apiDesc><apiOperationClassifier>Boolean</apiOperationClassifier></apiReturn><apiParam><apiItemName>name</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>The name of the definition.
     </apiDesc></apiParam></apiOperationDef><apiDesc>
     Checks to see if a public definition exists within the specified application domain.
     The definition can be that of a class, a namespace, or a function.
     
     </apiDesc></apiOperationDetail></apiOperation><apiValue id="flash.system:ApplicationDomain:MIN_DOMAIN_MEMORY_LENGTH:get"><apiName>MIN_DOMAIN_MEMORY_LENGTH</apiName><shortdesc>
	 Gets the minimum memory object length required to be used as
	 ApplicationDomain.domainMemory.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>uint</apiValueClassifier><apiTipTexts><apiTipText>
     </apiTipText></apiTipTexts></apiValueDef><apiDesc>
	 Gets the minimum memory object length required to be used as
	 ApplicationDomain.domainMemory.
	 
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:ApplicationDomain:currentDomain:get"><apiName>currentDomain</apiName><shortdesc>
     Gets the current application domain in which your code is executing.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><internal>Question: Do you call System.currentDomain? or Loader.currentDomain or request.currentDomain?
     
	 </internal></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>flash.system:ApplicationDomain</apiValueClassifier></apiValueDef><apiDesc>
     Gets the current application domain in which your code is executing.
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:ApplicationDomain:domainMemory:get"><apiName>domainMemory</apiName><shortdesc>
	 Gets and sets the object on which domain-global memory operations
	 will operate within this ApplicationDomain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiValueAccess value="readwrite"/><apiValueClassifier>flash.utils:ByteArray</apiValueClassifier><apiTipTexts><apiTipText>
     </apiTipText></apiTipTexts></apiValueDef><apiDesc>
	 Gets and sets the object on which domain-global memory operations
	 will operate within this ApplicationDomain.
	 
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:ApplicationDomain:parentDomain:get"><apiName>parentDomain</apiName><shortdesc>
     Gets the parent domain of this application domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiDynamic/><apiValueAccess value="read"/><apiValueClassifier>flash.system:ApplicationDomain</apiValueClassifier></apiValueDef><apiDesc>
     Gets the parent domain of this application domain.
     
	 </apiDesc></apiValueDetail></apiValue></apiClassifier><apiClassifier id="flash.system:Capabilities"><apiName>Capabilities</apiName><shortdesc>
 The Capabilities class provides properties that 
 describe the system and player that are hosting a SWF file.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities object, built-in class
  
  </keyword></asCustoms></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 <ph platform="actionscript">The Capabilities class provides properties that 
 describe the system and player that are hosting a SWF file.
 For example, a mobile phone's screen might be 100 square 
 pixels, black and white, whereas a PC screen might be 1000 square pixels, color. 
 By using the Capabilities object to determine what type of device a user has, 
 you can provide appropriate content to as many users as possible. When you know 
 the device's capabilities, you can tell the server to send the appropriate SWF 
 files or tell the SWF file to alter its presentation.</ph>
 
 <ph platform="javascript">The Capabilities class provides properties that describe 
 the system and runtime that are hosting HTML (and SWF) content.
 By using the Capabilities object to determine what type of computer a user has, 
 you can provide appropriate content to as many users as possible. When you know 
 the computer's capabilities, you can load appropriate content or use code to 
 alter its presentation.</ph>
 
 <p>However, some capabilities of Adobe AIR are not listed as properties in the
 Capabilities class. They are properties of other classes:</p>
 
 <adobetable class="innertable">
 
 
 
 
 
 
 
 
 
 
 
 
 
 <tgroup cols="2"><thead><row><entry>Property</entry><entry>Description</entry></row></thead><tbody><row>
 <entry><codeph>NativeApplication.supportsDockIcon</codeph></entry>
 <entry>Whether the operating system supports system dock icons.</entry>
 </row><row>
 <entry><codeph>NativeApplication.supportsMenu</codeph></entry>
 <entry>Whether the operating system supports a global application menu bar.</entry>
 </row><row>
 <entry><codeph>NativeApplication.supportsSystemTrayIcon</codeph></entry>
 <entry>Whether the operating system supports system tray icons.</entry>
 </row><row>
 <entry><codeph>NativeWindow.supportsMenu</codeph></entry>
 <entry>Whether the operating system supports window menus.</entry>
 </row><row>
 <entry><codeph>NativeWindow.supportsTransparency</codeph></entry>
 <entry>Whether the operating system supports transparent windows.</entry>
 </row></tbody></tgroup></adobetable>
 
 <p>Do <i>not</i> use <codeph>Capabilities.os</codeph> or <codeph>Capabilities.manufacturer</codeph> to 
 determine a capability based on the operating system. Basing a capability on the operating system 
 is a bad idea, since it can lead to problems if an application does not consider all potential 
 target operating systems. Instead, use the property corresponding to the capability for which you 
 are testing.</p>
 
 <p>You can send capabilities information, which is stored in the 
 <codeph>Capabilities.serverString</codeph> property as a URL-encoded string, using the 
 <codeph>GET</codeph> or <codeph>POST</codeph> HTTP method. The following example shows a server 
 string for a computer that has MP3 support and 1600 x 1200 pixel resolution and that is 
 running Windows XP with an input method editor (IME) installed:</p>
 
 <pre>A=t&amp;SA=t&amp;SV=t&amp;EV=t&amp;MP3=t&amp;AE=t&amp;VE=t&amp;ACC=f&amp;PR=t&amp;SP=t&amp;
     SB=f&amp;DEB=t&amp;V=WIN%209%2C0%2C0%2C0&amp;M=Adobe%20Windows&amp;
     R=1600x1200&amp;DP=72&amp;COL=color&amp;AR=1.0&amp;OS=Windows%20XP&amp;
     L=en&amp;PT=External&amp;AVD=f&amp;LFD=f&amp;WD=f&amp;IME=t</pre>
 
 <p>The following table lists the properties of the Capabilities class and corresponding server strings:
 <adobetable class="innertable">
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
   
  
  
  
  
  
  
  
  
 <tgroup cols="2"><thead><row><entry align="left">Capabilities class property</entry><entry align="left">Server string</entry></row></thead><tbody><row>
      <entry><codeph>avHardwareDisable</codeph></entry>
      <entry><codeph>AVD</codeph></entry>
  </row><row>
      <entry><codeph>hasAccessibility</codeph></entry>
      <entry><codeph>ACC</codeph></entry>
  </row><row>
      <entry><codeph>hasAudio</codeph></entry>
      <entry><codeph>A</codeph></entry>
  </row><row>
      <entry><codeph>hasAudioEncoder</codeph></entry>
      <entry><codeph>AE</codeph></entry>
  </row><row>
      <entry><codeph>hasEmbeddedVideo</codeph></entry>
      <entry><codeph>EV</codeph></entry>
  </row><row>
      <entry><codeph>hasIME</codeph></entry>
      <entry><codeph>IME</codeph></entry>
  </row><row>
      <entry><codeph>hasMP3</codeph></entry>
      <entry><codeph>MP3</codeph></entry>
  </row><row>
      <entry><codeph>hasPrinting</codeph></entry>
      <entry><codeph>PR</codeph></entry>
  </row><row>
      <entry><codeph>hasScreenBroadcast</codeph></entry>
      <entry><codeph>SB</codeph></entry>
  </row><row>
      <entry><codeph>hasScreenPlayback</codeph></entry>
      <entry><codeph>SP</codeph></entry>
  </row><row>
      <entry><codeph>hasStreamingAudio</codeph></entry>
      <entry><codeph>SA</codeph></entry>
  </row><row>
      <entry><codeph>hasStreamingVideo</codeph></entry>
      <entry><codeph>SV</codeph></entry>
  </row><row>
      <entry><codeph>hasTLS</codeph></entry>
      <entry><codeph>TLS</codeph></entry>
  </row><row>
      <entry><codeph>hasVideoEncoder</codeph></entry>
      <entry><codeph>VE</codeph></entry>
  </row><row>
      <entry><codeph>isDebugger</codeph></entry>
      <entry><codeph>DEB</codeph></entry>
  </row><row>
      <entry><codeph>language</codeph></entry>
      <entry><codeph>L</codeph></entry>
  </row><row>
      <entry><codeph>localFileReadDisable</codeph></entry>
      <entry><codeph>LFD</codeph></entry>
  </row><row>
      <entry><codeph>manufacturer</codeph></entry>
      <entry><codeph>M</codeph></entry>
  </row><row>
      <entry><codeph>maxLevelIDC</codeph></entry>
      <entry><codeph>ML</codeph></entry>
  </row><row>
      <entry><codeph>os</codeph></entry>
      <entry><codeph>OS</codeph></entry>
  </row><row>
      <entry><codeph>pixelAspectRatio</codeph></entry>
      <entry><codeph>AR</codeph></entry>
  </row><row>
      <entry><codeph>playerType</codeph></entry>
      <entry><codeph>PT</codeph></entry>
  </row><row>
      <entry><codeph>screenColor</codeph></entry>
      <entry><codeph>COL</codeph></entry>
  </row><row>
      <entry><codeph>screenDPI</codeph></entry>
      <entry><codeph>DP</codeph></entry>
  </row><row>
      <entry><codeph>screenResolutionX</codeph></entry>
      <entry><codeph>R</codeph></entry>
  </row><row>
      <entry><codeph>screenResolutionY</codeph></entry>
      <entry><codeph>R</codeph></entry>
  </row><row>
      <entry><codeph>version</codeph></entry>
      <entry><codeph>V</codeph></entry>
  </row></tbody></tgroup></adobetable>
 </p>
  
 <p>There is also a <codeph>WD</codeph> server string that specifies whether windowless mode is disabled. Windowless mode
 can be disabled in Flash Player due to incompatibility with the web browser or to a user setting in the mms.cfg file. 
 There is no corresponding Capabilities property.</p>
  
 <p>All properties of the Capabilities class are read-only.</p>
 
 </apiDesc><example conref="examples\CapabilitiesExample.as"> The following example simply outputs the values found in the
 flash.system.Capabilities object using several calls to <codeph>trace()</codeph>.
<codeblock>

package {
    import flash.display.Sprite;
    import flash.system.Capabilities;

    public class CapabilitiesExample extends Sprite {
        public function CapabilitiesExample() {
            showCapabilities();
        }
        
        private function showCapabilities():void {
            trace("avHardwareDisable: " + Capabilities.avHardwareDisable);
            trace("hasAccessibility: " + Capabilities.hasAccessibility);
            trace("hasAudio: " + Capabilities.hasAudio);
            trace("hasAudioEncoder: " + Capabilities.hasAudioEncoder);
            trace("hasEmbeddedVideo: " + Capabilities.hasEmbeddedVideo);
            trace("hasMP3: " + Capabilities.hasMP3);
            trace("hasPrinting: " + Capabilities.hasPrinting);
            trace("hasScreenBroadcast: " + Capabilities.hasScreenBroadcast);
            trace("hasScreenPlayback: " + Capabilities.hasScreenPlayback);
            trace("hasStreamingAudio: " + Capabilities.hasStreamingAudio);
            trace("hasVideoEncoder: " + Capabilities.hasVideoEncoder);
            trace("isDebugger: " + Capabilities.isDebugger);
            trace("language: " + Capabilities.language);
            trace("localFileReadDisable: " + Capabilities.localFileReadDisable);
            trace("manufacturer: " + Capabilities.manufacturer);
            trace("os: " + Capabilities.os);
            trace("pixelAspectRatio: " + Capabilities.pixelAspectRatio);
            trace("playerType: " + Capabilities.playerType);
            trace("screenColor: " + Capabilities.screenColor);
            trace("screenDPI: " + Capabilities.screenDPI);
            trace("screenResolutionX: " + Capabilities.screenResolutionX);
            trace("screenResolutionY: " + Capabilities.screenResolutionY);
            trace("serverString: " + Capabilities.serverString);
            trace("version: " + Capabilities.version);
        }
    }
}
</codeblock></example></apiClassifierDetail><apiValue id="flash.system:Capabilities:avHardwareDisable:get"><apiName>avHardwareDisable</apiName><shortdesc>
     Specifies whether access to the user's camera and microphone has
     been administratively prohibited (true) or allowed (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.avHardwareDisable, avHardwareDisable
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
     Specifies whether access to the user's camera and microphone has
     been administratively prohibited (<codeph>true</codeph>) or allowed (<codeph>false</codeph>).
     The server string is <codeph>AVD</codeph>.
     
	 <p>For content in Adobe AIR™, this property applies only to content in security  
	 sandboxes other than the application security sandbox. Content in the application 
	 security sandbox can always access the user's camera and microphone.</p>
 	 
     </apiDesc></apiValueDetail><related-links><link href="flash.media.xml#Camera/getCamera()"><linktext>flash.media.Camera.getCamera()</linktext></link><link href="flash.media.xml#Microphone/getMicrophone()"><linktext>flash.media.Microphone.getMicrophone()</linktext></link><link href="flash.system.xml#Security/showSettings()"><linktext>Security.showSettings()</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:cpuArchitecture:get"><apiName>cpuArchitecture</apiName><shortdesc>
	 Specifies the current CPU architecture on the machine.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="AIR" version="1.5.1"/></apiVersion></asMetadata><asCustoms><oldexample>The following example traces the value of this read-only property:
	 <pre>
	 trace(Capabilities.cpuArchitecture);
	 </pre>
	 </oldexample></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the current CPU architecture on the machine. The <codeph>cpuArchitecture</codeph> property
	 can return the following strings: "<codeph>PowerPC</codeph>", "<codeph>x86</codeph>", 
	 "<codeph>SPARC</codeph>", and "<codeph>ARM</codeph>". 
	 The server string is <codeph>ARCH</codeph>.
	 
	 </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasAccessibility:get"><apiName>hasAccessibility</apiName><shortdesc>
	 Specifies whether the system supports 
     (true) or does not support (false) communication 
     with accessibility aids.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasAccessibility, hasAccessibility,
     accessibility
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system supports 
     (<codeph>true</codeph>) or does not support (<codeph>false</codeph>) communication 
     with accessibility aids.
     The server string is <codeph>ACC</codeph>. 
     
     </apiDesc></apiValueDetail><related-links><link href="flash.accessibility.xml#Accessibility/active"><linktext>flash.accessibility.Accessibility.active</linktext></link><link href="flash.accessibility.xml#Accessibility/updateProperties()"><linktext>flash.accessibility.Accessibility.updateProperties()</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:hasAudio:get"><apiName>hasAudio</apiName><shortdesc>
	 Specifies whether the system has audio 
     capabilities.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasAudio, hasAudio
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system has audio 
     capabilities. This property is always <codeph>true</codeph>.  The server 
     string is <codeph>A</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasAudioEncoder:get"><apiName>hasAudioEncoder</apiName><shortdesc>
	 Specifies whether the system can (true) or cannot (false)
     encode an audio stream, such as that coming from a microphone.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasAudioEncoder, hasAudioEncoder 
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system can (<codeph>true</codeph>) or cannot (<codeph>false</codeph>)
     encode an audio stream, such as that coming from a microphone.
     The server string is <codeph>AE</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasEmbeddedVideo:get"><apiName>hasEmbeddedVideo</apiName><shortdesc>
	 Specifies whether the system supports 
     (true) or does not support (false) 
     embedded video.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasEmbeddedVideo, hasEmbeddedVideo, video
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system supports 
     (<codeph>true</codeph>) or does not support (<codeph>false</codeph>) 
     embedded video. The server string is <codeph>EV</codeph>. 
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasIME:get"><apiName>hasIME</apiName><shortdesc>
	 Specifies whether the system does (true) 
     or does not (false) have an input method editor (IME) installed.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasIME, hasIME, IME 
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system does (<codeph>true</codeph>) 
     or does not (<codeph>false</codeph>) have an input method editor (IME) installed.
     The server string is <codeph>IME</codeph>. 
     
     </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IME"><linktext>flash.system.IME</linktext></link><link href="flash.system.xml#System/ime"><linktext>flash.system.System.ime</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:hasMP3:get"><apiName>hasMP3</apiName><shortdesc>
	 Specifies whether the system does (true) 
     or does not (false) have an MP3 decoder.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasMP3, hasMP3, MP3, audio
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system does (<codeph>true</codeph>) 
     or does not (<codeph>false</codeph>) have an MP3 decoder.
     The server string is <codeph>MP3</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasPrinting:get"><apiName>hasPrinting</apiName><shortdesc>
	 Specifies whether the system does (true)
     or does not (false) support printing.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasPrinting, hasPrinting, printing 
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system does (<codeph>true</codeph>)
     or does not (<codeph>false</codeph>) support printing.
     The server string is <codeph>PR</codeph>. 
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasScreenBroadcast:get"><apiName>hasScreenBroadcast</apiName><shortdesc>
	 Specifies whether the system does (true) or does not (false)
     support the development of screen broadcast applications to be run through Flash Media 
     Server.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasScreenBroadcast, hasScreenBroadcast
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system does (<codeph>true</codeph>) or does not (<codeph>false</codeph>)
     support the development of screen broadcast applications to be run through Flash Media 
     Server.
     The server string is <codeph>SB</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasScreenPlayback:get"><apiName>hasScreenPlayback</apiName><shortdesc>
	 Specifies whether the system does (true) or does not 
     (false) support the playback of screen broadcast applications 
     that are being run through Flash Media Server.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasScreenPlayback, hasScreenPlayback
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system does (<codeph>true</codeph>) or does not 
     (<codeph>false</codeph>) support the playback of screen broadcast applications 
     that are being run through Flash Media Server.
     The server string is <codeph>SP</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasStreamingAudio:get"><apiName>hasStreamingAudio</apiName><shortdesc>
	 Specifies whether the system can (true) or cannot (false) 
     play streaming audio.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasStreamingAudio, hasStreamingAudio, audio
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system can (<codeph>true</codeph>) or cannot (<codeph>false</codeph>) 
     play streaming audio.
     The server string is <codeph>SA</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasStreamingVideo:get"><apiName>hasStreamingVideo</apiName><shortdesc>
	 Specifies whether the system can (true) or cannot 
     (false) play streaming video.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasStreamingVideo, hasStreamingVideo, video
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system can (<codeph>true</codeph>) or cannot 
     (<codeph>false</codeph>) play streaming video.
     The server string is <codeph>SV</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:hasTLS:get"><apiName>hasTLS</apiName><shortdesc>
	 Specifies whether the system supports native SSL sockets through NetConnection 
     (true) or does not (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasTLS, hasTLS, TLS 
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system supports native SSL sockets through NetConnection 
     (<codeph>true</codeph>) or does not (<codeph>false</codeph>).
     The server string is <codeph>TLS</codeph>.
     
     </apiDesc></apiValueDetail><related-links><link href="flash.net.xml#NetConnection/connectedProxyType"><linktext>flash.net.NetConnection.connectedProxyType</linktext></link><link href="flash.net.xml#NetConnection/proxyType"><linktext>flash.net.NetConnection.proxyType</linktext></link><link href="flash.net.xml#NetConnection/usingTLS"><linktext>flash.net.NetConnection.usingTLS</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:hasVideoEncoder:get"><apiName>hasVideoEncoder</apiName><shortdesc>
	 Specifies whether the system can (true) or cannot 
     (false) encode a video stream, such as that coming 
     from a web camera.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.hasVideoEncoder, hasVideoEncoder
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies whether the system can (<codeph>true</codeph>) or cannot 
     (<codeph>false</codeph>) encode a video stream, such as that coming 
     from a web camera.
     The server string is <codeph>VE</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:isDebugger:get"><apiName>isDebugger</apiName><shortdesc> 
	 Specifies whether the system is a special debugging version 
	 (true) or an officially released version (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.isDebugger, isDebugger, debugging 
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc> 
	 Specifies whether the system is a special debugging version 
	 (<codeph>true</codeph>) or an officially released version (<codeph>false</codeph>). 
	 The server string is <codeph>DEB</codeph>. This property is set to <codeph>true</codeph>
	 when running in <ph platform="actionscript">the debug version of Flash Player or</ph>
	 the AIR Debug Launcher (ADL).
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:isEmbeddedInAcrobat:get"><apiName>isEmbeddedInAcrobat</apiName><shortdesc>
     Specifies whether the player is embedded in a PDF file that is open in Acrobat 9.0 or higher
     (true) or not (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9.0.127.0"/><apiPlatform description="" name="AIR" version="1.1"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.isEmbeddedInAcrobat, isEmbeddedInAcrobat, Acrobat
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
     Specifies whether the player is embedded in a PDF file that is open in Acrobat 9.0 or higher
     (<codeph>true</codeph>) or not (<codeph>false</codeph>).
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:language:get"><apiName>language</apiName><shortdesc>
	 Specifies the language code of the system on which the content is running.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.language, language
     
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the language code of the system on which the content is running. The language is
     specified as a lowercase two-letter language code from ISO 639-1. For Chinese, an additional
     uppercase two-letter country code from ISO 3166 distinguishes between Simplified and
     Traditional Chinese. The languages codes are based on the English names of the language: for example, 
     <codeph>hu</codeph> specifies Hungarian.
     
     <p>On English systems, this property returns only the language code (<codeph>en</codeph>), not 
     the country code. On Microsoft Windows systems, this property returns the user interface (UI) 
     language, which refers to the language used for all menus, dialog boxes, error messages, and help 
     files. The following table lists the possible values:
     
     <adobetable class="innertable">
     
     
     
     
     
         
         
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     <tgroup cols="2"><thead><row><entry align="left">Language</entry><entry align="left">Value</entry></row></thead><tbody><row>
      <entry>Czech</entry>
      <entry><codeph>cs</codeph></entry>
     </row><row>
      <entry>Danish</entry>
      <entry><codeph>da</codeph></entry>
     </row><row>
      <entry>Dutch</entry>
      <entry><codeph>nl</codeph></entry>
     </row><row>
      <entry>English</entry>
      <entry><codeph>en</codeph></entry>
     </row><row>
      <entry>Finnish</entry>
      <entry><codeph>fi</codeph></entry>
     </row><row>
      <entry>French</entry>
      <entry><codeph>fr</codeph></entry>
     </row><row>
      <entry>German</entry>
      <entry><codeph>de</codeph></entry>
     </row><row>
      <entry>Hungarian</entry>
      <entry><codeph>hu</codeph></entry>
     </row><row>
      <entry>Italian</entry>
      <entry><codeph>it</codeph></entry>
     </row><row>
      <entry>Japanese</entry>
      <entry><codeph>ja</codeph></entry>
     </row><row>
      <entry>Korean</entry>
      <entry><codeph>ko</codeph></entry>
     </row><row>
      <entry>Norwegian</entry>
      <entry><codeph>no</codeph></entry>
     </row><row>
      <entry>Other/unknown</entry>
      <entry><codeph>xu</codeph></entry>
     </row><row>
      <entry>Polish</entry>
      <entry><codeph>pl</codeph></entry>
     </row><row>
      <entry>Portuguese</entry>
      <entry><codeph>pt</codeph></entry>
     </row><row>
      <entry>Russian</entry>
      <entry><codeph>ru</codeph></entry>
     </row><row>
      <entry>Simplified Chinese</entry>
      <entry><codeph>zh-CN</codeph></entry>
     </row><row>
      <entry>Spanish</entry>
      <entry><codeph>es</codeph></entry>
     </row><row>
      <entry>Swedish</entry>
      <entry><codeph>sv</codeph></entry>
     </row><row>
      <entry>Traditional Chinese</entry>
      <entry><codeph>zh-TW</codeph></entry>
     </row><row>
      <entry>Turkish</entry>
      <entry><codeph>tr</codeph></entry>
     </row></tbody></tgroup></adobetable>
     </p>
	 
	 <p><i>Note:</i> The value of <codeph>Capabilities.language</codeph> property is limited 
	 to the possible values on this list. Because of this limitation, Adobe AIR applications 
	 should use the first element in the <codeph>Capabilities.languages</codeph> 
	 array to determine the primary user interface language for the system. </p>
	 
     <p>The server string is <codeph>L</codeph>.</p>
     
     </apiDesc><example conref="examples\Capabilities_languageExample.as"> In the following example, the content that is displayed depends on the language of the user's operating
 system.
 
 <p>The <codeph>Capabilities.language</codeph> property returns the ISO 639-1 language code 
 (for example, "en" for English). The <codeph>switch</codeph> statement checks for the language code and sets  
 the content of the <codeph>myTextField</codeph> text field to a greeting specific to the 
 language. If the language code is not supported by the example, the default error string 
 is returned.</p>
 
<codeblock>
package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.system.Capabilities;

    public class Capabilities_languageExample extends Sprite {

        public function Capabilities_languageExample()  {
            var myTextField:TextField = new TextField();         
            myTextField.x = 10;
            myTextField.y = 10;
            myTextField.background = true;
            myTextField.autoSize = TextFieldAutoSize.LEFT;
            
            var greetingEnglish:String = "Hello World";
            var greetingGerman:String = "Hallo Welt";
            var greetingFrench:String = "Bonjour Monde";
            var greetingSpanish:String = "Hola Mundo";

            var lang:String = Capabilities.language;
                         
            switch (lang) {
                case "en":
                    myTextField.text = greetingEnglish;
                    break;
                case "de":
                    myTextField.text = greetingGerman;
                    break;
                case "fr":
                    myTextField.text = greetingFrench;
                    break;
                case "es":
                    myTextField.text = greetingSpanish;
                    break;
                default:
                    myTextField.text = "Sorry your system's language is not supported at this time.";               
            }
             
            this.addChild(myTextField);
        }
    }
}
</codeblock></example></apiValueDetail><related-links><link href="flash.system.xml#Capabilities/languages"><linktext>languages</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:languages:get"><apiName>languages</apiName><shortdesc>
	 An array of strings that contain information about the user's preferred user interface languages, as set 
	 through the operating system.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="AIR" version="1.1"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Array</apiValueClassifier></apiValueDef><apiDesc>
	 An array of strings that contain information about the user's preferred user interface languages, as set 
	 through the operating system. The strings will contain language tags (and script and region information,
	 where applicable) defined by RFC4646 
	 (<xref href="http://www.ietf.org/rfc/rfc4646.txt" scope="external">http://www.ietf.org/rfc/rfc4646.txt</xref>)
	 and will use dashes as a delimiter (for example, <codeph>"en-US"</codeph> or <codeph>"ja-JP"</codeph>). 
	 Languages are listed in the array in the order of preference, as determined by the operating system 
	 settings. 
	 
	 <p>Operating systems differ in region information returned in locale strings. One operating system
	 may return <codeph>"en-us"</codeph>, whereas another may return <codeph>"en"</codeph>.</p>
	 
	 <p>The first entry in the returned array generally has the same primary language ID
	 as the <codeph>Capabilities.language</codeph> property. For example, if <codeph>Capabilities.languages[0]</codeph> 
	 is set to <codeph>"en-US"</codeph>, then the <codeph>language</codeph> property is set to <codeph>"en"</codeph>.
	 However, if the <codeph>Capabilities.language</codeph> property is set to <codeph>"xu"</codeph> (specifying 
	 an unknown language), the first element in this array will be different. For this reason, 
	 <codeph>Capabilities.languages[0]</codeph> can be more accurate than <codeph>Capabilities.language</codeph>.</p>
	 
	 <p>The server string is <codeph>LS</codeph>.</p>
	 
	 </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:localFileReadDisable:get"><apiName>localFileReadDisable</apiName><shortdesc>
     Specifies whether read access to the user's hard disk has been 
     administratively prohibited (true) or allowed 
	 (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.localFileReadDisable, localFileReadDisable
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
     Specifies whether read access to the user's hard disk has been 
     administratively prohibited (<codeph>true</codeph>) or allowed 
	 (<codeph>false</codeph>). For content in Adobe AIR, this property 
	 applies only to content in security sandboxes other 
	 than the application security sandbox. (Content in the application 
	 security sandbox can always read from the file system.) 
	 <ph platform="actionscript">If this property is <codeph>true</codeph>, 
	 Flash Player cannot read files (including the first file that
	 Flash Player launches with) from the user's hard disk.</ph> 
	 If this property is <codeph>true</codeph>, AIR content outside of the 
	 application security sandbox cannot read files from the user's 
	 hard disk. For example, attempts to read a file on the user's 
	 hard disk using load methods will fail if this property 
	 is set to <codeph>true</codeph>.
	 
	 <p platform="actionscript">Reading runtime shared libraries is also blocked  
	 if this property is set to <codeph>true</codeph>, but reading local shared objects 
	 is allowed without regard to the value of this property.</p>
	 
	 <p>The server string is <codeph>LFD</codeph>.</p>
     
     
     </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader"><linktext>flash.display.Loader</linktext></link></related-links></apiValue><apiValue id="flash.system:Capabilities:manufacturer:get"><apiName>manufacturer</apiName><shortdesc>
	 Specifies the manufacturer of the running version of 
	 Flash Player or  the AIR runtime, in the format "Adobe 
	 OSName".</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.manufacturer, manufacturer
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the manufacturer of <ph platform="actionscript">the running version of 
	 Flash Player or </ph> the AIR runtime, in the format <codeph>"Adobe</codeph> 
	 <codeph><i>OSName</i>"</codeph>. The value for <codeph><i>OSName</i></codeph> 
	 could be <codeph>"Windows"</codeph>, <codeph>"Macintosh"</codeph>,
     <codeph>"Linux"</codeph>, or another operating system name. The server string is <codeph>M</codeph>.
     
	 <p>Do <i>not</i> use <codeph>Capabilities.manufacturer</codeph> to determine a capability based on 
	 the operating system if a more specific capability property exists. Basing a capability on the operating 
	 system is a bad idea, since it can lead to problems if an application does not consider all potential 
	 target operating systems. Instead, use the property corresponding to the capability for which you 
	 are testing. For more information, see the Capabilities class description.</p>
	 
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:maxLevelIDC:get"><apiName>maxLevelIDC</apiName><shortdesc>
     Retrieves the highest H.264 Level IDC that the client hardware supports.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.maxLevelIDC, maxLevelIDC
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     Retrieves the highest H.264 Level IDC that the client hardware supports.
     Media run at this level are guaranteed to run; however, media run at  
     the highest level might not run with the highest quality. 
     This property is useful for servers trying to target a client's capabilities.
     Using this property, a server can determine the level of video to send to the client.
     
     <p>The server string is <codeph>ML</codeph>.</p>
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:os:get"><apiName>os</apiName><shortdesc>
     Specifies the current operating system.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.os, os
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     Specifies the current operating system. The <codeph>os</codeph> property
     can return the following strings: "<codeph>Windows XP</codeph>", "<codeph>Windows 2000</codeph>", 
     "<codeph>Windows NT</codeph>", "<codeph>Windows 98/ME</codeph>", "<codeph>Windows 95</codeph>", 
     "<codeph>Windows CE</codeph>" (available only in Flash Player SDK, not in the desktop version), 
     <codeph>"Linux"</codeph>, and <codeph>"Mac OS X.Y.Z"</codeph> (where X.Y.Z is the version number, for example:
     <codeph>Mac OS 10.5.2</codeph>).
     The server string is <codeph>OS</codeph>.
     
	 <p>Do <i>not</i> use <codeph>Capabilities.os</codeph> to determine a capability based on 
	 the operating system if a more specific capability property exists. Basing a capability on the operating 
	 system is a bad idea, since it can lead to problems if an application does not consider all potential 
	 target operating systems. Instead, use the property corresponding to the capability for which you 
	 are testing. For more information, see the Capabilities class description.</p>
	 
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:pixelAspectRatio:get"><apiName>pixelAspectRatio</apiName><shortdesc> 
     Specifies the pixel aspect ratio of the screen.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.pixelAspectRatio, pixelAspectRatio
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Number</apiValueClassifier></apiValueDef><apiDesc> 
     Specifies the pixel aspect ratio of the screen. The server string
     is <codeph>AR</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:playerType:get"><apiName>playerType</apiName><shortdesc>
	 Specifies the type of runtime environment.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.playerType, playerType
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
	 Specifies the type of runtime environment. This property can have one of the following
     values:
	 
     <ul>
	   <li><codeph>"ActiveX"</codeph> for the Flash Player ActiveX control used by Microsoft Internet Explorer</li>
	   <li><codeph>"Desktop"</codeph> for the Adobe AIR runtime (except for SWF content loaded by an HTML page, which
	 					has <codeph>Capabilities.playerType</codeph> set to <codeph>"PlugIn"</codeph>)</li>
	   <li><codeph>"External"</codeph> for the external Flash Player<ph outputclass="flashonly"> or in test mode</ph></li>
	   <li><codeph>"PlugIn"</codeph> for the Flash Player browser plug-in (and for SWF content loaded by
	 					an HTML page in an AIR application)</li>
       <li><codeph>"StandAlone"</codeph> for the stand-alone Flash Player</li>
     </ul>
     <p>The server string is <codeph>PT</codeph>.</p>
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:screenColor:get"><apiName>screenColor</apiName><shortdesc>
     Specifies the screen color.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.screenColor, screenColor
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc>
     Specifies the screen color. This property can have the value 
	 <codeph>"color"</codeph>, <codeph>"gray"</codeph> (for grayscale), or 
	 <codeph>"bw"</codeph> (for black and white). 
     The server string is <codeph>COL</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:screenDPI:get"><apiName>screenDPI</apiName><shortdesc>
     Specifies the dots-per-inch (dpi) resolution of the screen, in pixels.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.screenDPI, screenDPI
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Number</apiValueClassifier></apiValueDef><apiDesc>
     Specifies the dots-per-inch (dpi) resolution of the screen, in pixels.
     The server string is <codeph>DP</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:screenResolutionX:get"><apiName>screenResolutionX</apiName><shortdesc>
     Specifies the maximum horizontal resolution of the screen.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.screenResolutionX, screenResolutionY
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Number</apiValueClassifier></apiValueDef><apiDesc>
     Specifies the maximum horizontal resolution of the screen. 
     The server string is <codeph>R</codeph> (which returns both the width and height of the screen).
	 This property does not update with a user's screen resolution and instead only indicates the resolution 
	 at the time <ph platform="actionscript">Flash Player or </ph> an Adobe AIR application started. 
	 Also, the value only specifies the main monitor.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:screenResolutionY:get"><apiName>screenResolutionY</apiName><shortdesc> 
     Specifies the maximum vertical resolution of the screen.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.screenResolutionY, screenResolutionY
     </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Number</apiValueClassifier></apiValueDef><apiDesc> 
     Specifies the maximum vertical resolution of the screen. 
     The server string is <codeph>R</codeph> (which returns both the width and height of the screen).
	 This property does not update with a user's screen resolution and instead only indicates the resolution 
	 at the time <ph platform="actionscript">Flash Player or </ph> an Adobe AIR application started. 
	 Also, the value only specifies the main monitor.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:serverString:get"><apiName>serverString</apiName><shortdesc> 
     A URL-encoded string that specifies values for each Capabilities
     property.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.serverString, serverString
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc> 
     A URL-encoded string that specifies values for each Capabilities
     property.
	 
     <p>The following example shows a URL-encoded string:
     <pre>A=t&amp;SA=t&amp;SV=t&amp;EV=t&amp;MP3=t&amp;AE=t&amp;VE=t&amp;ACC=f&amp;PR=t&amp;SP=t&amp;
     SB=f&amp;DEB=t&amp;V=WIN%208%2C5%2C0%2C208&amp;M=Adobe%20Windows&amp;
     R=1600x1200&amp;DP=72&amp;COL=color&amp;AR=1.0&amp;OS=Windows%20XP&amp;
     L=en&amp;PT=External&amp;AVD=f&amp;LFD=f&amp;WD=f</pre></p>
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:supports32BitProcesses:get"><apiName>supports32BitProcesses</apiName><shortdesc>
     Specifies whether the system supports running 32-bit processes.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5.2"/></apiVersion></asMetadata><asCustoms><oldexample>The following example traces the value of this read-only property:
     <pre>
     trace(Capabilities.supports32BitProcesses);
     </pre>
     </oldexample></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
     Specifies whether the system supports running 32-bit processes.
     The server string is <codeph>PR32</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:supports64BitProcesses:get"><apiName>supports64BitProcesses</apiName><shortdesc>
     Specifies whether the system supports running 64-bit processes.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="10"/><apiPlatform description="" name="AIR" version="1.5.2"/></apiVersion></asMetadata><asCustoms><oldexample>The following example traces the value of this read-only property:
     <pre>
     trace(Capabilities.supports64BitProcesses);
     </pre>
     </oldexample></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
     Specifies whether the system supports running 64-bit processes.
     The server string is <codeph>PR64</codeph>.
     
     </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:Capabilities:version:get"><apiName>version</apiName><shortdesc> 
	 Specifies the Flash Player or Adobe&amp;#xAE; AIR&amp;#xAE;
	 platform and version information.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><keyword>Capabilities, Capabilities.version, version
	  
	  </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>String</apiValueClassifier></apiValueDef><apiDesc> 
	 Specifies the Flash Player or Adobe<sup>®</sup> AIR<sup>®</sup>
	 platform and version information. The format of the version number is: 
	 <i>platform majorVersion,minorVersion,buildNumber,internalBuildNumber</i>. 
	 Possible values for <i>platform</i> are <codeph>"WIN"</codeph>, `
	 <codeph>"MAC"</codeph>, and <codeph>"LNX"</codeph>. Here are some examples of 
     version information:
	 
     <pre>
     WIN 9,0,0,0  // Flash Player 9 for Windows
     MAC 7,0,25,0   // Flash Player 7 for Macintosh
	 LNX 9,0,115,0  // Flash Player 9 for Linux
     </pre>
	 
	 <p>Do <i>not</i> use <codeph>Capabilities.version</codeph> to determine a capability based on 
	 the operating system if a more specific capability property exists. Basing a capability on the operating 
	 system is a bad idea, since it can lead to problems if an application does not consider all potential 
	 target operating systems. Instead, use the property corresponding to the capability for which you 
	 are testing. For more information, see the Capabilities class description.</p>
	 
     <p>The server string is <codeph>V</codeph>.</p>
     
     </apiDesc></apiValueDetail></apiValue></apiClassifier><apiOperation id="globalOperation:flash.system:fscommand"><apiName>fscommand</apiName><shortdesc>
 Lets the SWF file communicate with either Flash Player or the program hosting Flash Player, 
 such as a web browser.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/><apiPlatform description="" name="AIR" version="1.0"/></apiVersion></asMetadata><asCustoms><oldexample><p>In the following example, the <code>fscommand()</code> function sets Flash Player to 
 scale the SWF file to the full monitor screen size when the <code>fullscreen_btn</code> button or 
 <code>unfullscreen_btn</code> is released:</p>
 
 <pre>this.fullscreen_btn.onRelease = function() {
   fscommand(&quot;fullscreen&quot;, true);
 };
 this.unfullscreen_btn.onRelease = function() {
   fscommand(&quot;fullscreen&quot;, false);
 };
 </pre>
 
 <p>The following example uses the <code>fscommand()</code> function applied to a button in Flash to 
 open a JavaScript message box in an HTML page. The message itself is sent to JavaScript as the 
 <code>fscommand</code> parameter. </p>
 
 <p>You must add a function to the HTML page that contains the SWF file. This function, 
 <code><i>myDocument</i></code><code>_DoFSCommand</code>, sits in the HTML page and waits for an 
 <code>fscommand()</code> function in Flash. When an <code>fscommand</code> is triggered in Flash 
 (for example, when a user presses the button), the <code>command</code> and <code>args</code> strings 
 are passed to the <code><i>myDocument</i></code><code>_DoFSCommand </code>function. You can use the 
 passed strings in your JavaScript or VBScript code in any way you like. In this example, the function 
 contains a conditional <code>if</code> statement that checks to see if the command string is 
 &quot;<code>messagebox</code>&quot;. If it is, a JavaScript alert box (or &quot;message box&quot;) opens 
 and displays the contents of the <code>args</code> string.</p>
 
 <pre>function myDocument_DoFSCommand(command, args) {
   if (command == &quot;messagebox&quot;) {
      alert(args);
   }
 
 </pre>
 
 <p>In the Flash document, add the <code>fscommand()</code> function to a button:</p>
 
 <pre>fscommand(&quot;messagebox&quot;, &quot;This is a message box called from within Flash.&quot;)
 </pre>
 
 <p>You can also use expressions for the <code>fscommand()</code> function and parameters, as in the 
 following example:</p>
 
 <pre>fscommand(&quot;messagebox&quot;, &quot;Hello, &quot; + name + &quot;, welcome to our website!&quot;)
 </pre>
 
 <p>To test the SWF file, select File &gt; Publish Preview &gt; HTML.</p>
 
 <p><strong>Note: </strong>If you publish your SWF file using the Flash with FSCommand template in the 
 HTML 
 tab of the Publish Settings dialog box, the <code>myDocument_DoFSCommand</code> function is inserted 
 automatically. The SWF file's <code>NAME</code> and <code>ID</code> attributes will be the filename. 
 For example, for the file myDocument.fla, the attributes would be set to <code>myDocument</code>.</p>
 
  
  </oldexample></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiException><apiDesc>If the function is not called in response to a user action, such as a mouse
 event or keypress event.
 
 </apiDesc><apiItemName>Error</apiItemName><apiOperationClassifier>Error</apiOperationClassifier></apiException><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>command</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>A string passed to the host application for any use, or a command passed to Flash Player.
 
 </apiDesc></apiParam><apiParam><apiItemName>args</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiData></apiData><apiDesc>A string passed to the host application for any use, or a value passed to Flash Player.
 
 </apiDesc></apiParam></apiOperationDef><apiDesc>
 Lets the SWF file communicate with either Flash Player or the program hosting Flash Player, 
 such as a web browser. You can also use the <codeph>fscommand()</codeph> function to pass messages to 
 Director or to Visual Basic, Visual C++, and other programs that can host ActiveX controls.
 
  
 <p>The <codeph>fscommand()</codeph> function lets a SWF file communicate with a script in a web page. 
  However, script access is controlled by the web page's <codeph>allowScriptAccess</codeph> setting. 
  (You set this attribute in the HTML code that embeds the SWF file—for
  example, in the <codeph>PARAM</codeph> tag for Internet Explorer or the <codeph>EMBED</codeph> tag for Netscape.) </p>
  <ul>
  
  <li> When <codeph>allowScriptAccess</codeph> is set to <codeph>"sameDomain"</codeph> (the default), 
  scripting is allowed only from SWF files that are in the same domain as the web page. </li> 
  <li> When <codeph>allowScriptAccess</codeph> is set to <codeph>"always"</codeph>, 
  the SWF file can communicate with the HTML page in which it is embedded 
  even when the SWF file is from a different domain than the HTML page. </li>
  <li>When <codeph>allowScriptAccess</codeph> is set to <codeph>"never"</codeph>, 
  the SWF file cannot communicate with any HTML page. Note that using this value is deprecated and not recommended, 
  and shouldn't be necessary if you don't serve untrusted SWF files from your own domain. 
  If you do need to serve untrusted SWF files, Adobe recommends that you create a distinct subdomain 
  and place all untrusted content there. </li>
 </ul>
 
 <p>You can prevent a SWF file from using this method by setting the 
 <codeph>allowNetworking</codeph> parameter of the the <codeph>object</codeph> and <codeph>embed</codeph> 
 tags in the HTML page that contains the SWF content. </p>
 
 <p>The <codeph>fscommand()</codeph> function is not allowed if the calling SWF file is in 
  the local-with-file-system or local-with-network sandbox and the containing HTML page is in 
  an untrusted sandbox.</p>
 
 <p>For more security-related information, see the following:</p>
 <ul>
 
 <li class="flexonly">The <xref href="http://www.adobe.com/go/flex3_progAS3_security" scope="external">security chapter</xref> in the
 <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
 <li class="flashonly">The <xref href="http://www.adobe.com/go/flashcs4_prog_as3_security_en" scope="external">security chapter</xref>
 in the <i>Programming ActionScript 3.0</i> book and the latest comments on LiveDocs</li>
 
 <li>The Flash Player Developer Center Topic: <xref href="http://www.adobe.com/go/devnet_security_en" scope="external">Security</xref></li>
 </ul>
 
 <p>Usage 1: To use <codeph>fscommand()</codeph> to send a message to Flash Player, you must use predefined commands and parameters. The 
 following table shows the values that you can specify for the <codeph>fscommand()</codeph> function's <codeph>command</codeph> and 
 <codeph>args</codeph> parameters. These values control SWF files that are playing in Flash Player, including projectors. (A 
 <i>projector</i> is a SWF file saved in a format that can run as a stand-alone application—that is, without Flash Player.)</p>
 
              <adobetable class="innertable">
                  
                  
                  
                  
                  
                  
                  
                  
              <tgroup cols="3"><thead><row><entry>Command</entry><entry>Parameter (args)</entry><entry>Purpose</entry></row></thead><tbody><row>
                      <entry><codeph>quit</codeph></entry>
                      <entry>None</entry>
                      <entry>Closes the projector.</entry>
                  </row><row>
                      <entry><codeph>fullscreen</codeph></entry>
                      <entry><codeph>true</codeph> or <codeph>false</codeph></entry>
                      <entry>Specifying <codeph>true</codeph> sets Flash Player to full-screen mode. Specifying 
                      <codeph>false</codeph> returns the player to normal menu view.</entry>
                  </row><row>
                      <entry><codeph>allowscale</codeph></entry> 
                      <entry><codeph>true</codeph> or <codeph>false</codeph></entry>
                      <entry>Specifying <codeph>false</codeph> sets the player so that the SWF file is always drawn 
                      at its original size and never scaled. Specifying <codeph>true</codeph> forces the SWF file to scale to 100% of the 
                      player.</entry>
                  </row><row>
                      <entry><codeph>showmenu</codeph></entry>
                      <entry><codeph>true</codeph> or <codeph>false</codeph></entry>
                      <entry>Specifying <codeph>true</codeph> enables the full set of context menu items. Specifying 
                      <codeph>false</codeph> hides all of the context menu items except About Flash Player and Settings.</entry>
                  </row><row>
                      <entry><codeph>exec</codeph></entry>
                      <entry>Path to application </entry>
                      <entry>Executes an application from within the projector.</entry>
                  </row><row>
                      <entry><codeph>trapallkeys</codeph></entry>
                      <entry><codeph>true</codeph> or <codeph>false</codeph></entry>
                      <entry>Specifying <codeph>true</codeph> sends all key events, including accelerator keys, to 
                      the <codeph>onClipEvent(keyDown/keyUp)</codeph> handler in Flash Player. </entry>
                  </row></tbody></tgroup></adobetable>
 <p>Not all of the commands listed in the table are available in all applications: 
 <ul>
     <li>None of the commands are available in web players.</li> 
     <li>All of the commands are available in stand-alone applications, such as projectors.</li>
     <li>Only <codeph>allowscale</codeph> and <codeph>exec</codeph> are available in test-movie players.</li>
 </ul>
 </p>
 
 <p>The <codeph>exec</codeph> command can contain only the characters A-Z, a-z, 0-9, period (.), and underscore (_). The <codeph>exec</codeph>
 command runs in the subdirectory fscommand only. In other words, if you use the <codeph>exec</codeph> command to call an application, the
 application must reside in a subdirectory named fscommand. The <codeph>exec</codeph> command works only from within a Flash projector  
 file.</p>
 
 <p>Usage 2: To use <codeph>fscommand()</codeph> to send a message to a scripting language such as JavaScript in a web browser, you can 
 pass any two parameters in the <codeph>command</codeph> and <codeph>args</codeph> parameters. These parameters can be strings or  
 expressions, and they are used in a JavaScript function that handles, or <i>catches</i>, the <codeph>fscommand()</codeph> function. </p>
 
 <p>In a web browser, <codeph>fscommand()</codeph> calls the JavaScript function <codeph>moviename_DoFScommand</codeph>, which resides in the  
 web page that contains the SWF file. For <codeph>moviename</codeph>, supply the name of the Flash object that you used for the 
 <codeph>NAME</codeph> attribute of the <codeph>EMBED</codeph> tag or the ID property of the <codeph>OBJECT</codeph> tag. If you assign the SWF file
 the name "myMovie", the JavaScript function <codeph>myMovie_DoFScommand</codeph> is called. </p>
 
 <p>In the web page that contains the SWF file, set the <codeph>allowScriptAccess</codeph> attribute to allow or deny the SWF file's 
 ability to access the web page, as described above. (You set this attribute in the HTML code that embeds the SWF file—for example, in the 
 <codeph>PARAM</codeph> tag for Internet Explorer or the <codeph>EMBED</codeph> tag for Netscape.) </p>
 
 <p>In Flash Player 10 and later running in a browser, using this method programmatically to
 open a pop-up window may not be successful.  Various browsers (and browser configurations) may block pop-up windows 
 at any time; it is not possible to guarantee any pop-up window will appear.  
 However, for the best chance of success, use this method to open a pop-up window only in code that executes 
 as a direct result of a user action (for example, in an event handler for a mouse click or key-press event.)</p>
 
 <p>Usage 3: The <codeph>fscommand()</codeph> function can send messages to Director (Macromedia Director from Adobe). 
 These messages are interpreted by Lingo (the Director scripting language) as strings, events, or executable Lingo 
 code. If a message is a string or an event, you must write the Lingo code to receive the message from the 
 <codeph>fscommand()</codeph> function and carry out an action in Director. For more information, see the Director Support 
 Center at <xref href="http://www.adobe.com/support/director/" scope="external">www.adobe.com/support/director/</xref>.</p>
 
 <p>Usage 4: In VisualBasic, Visual C++, and other programs that can host ActiveX controls, <codeph>fscommand()</codeph> sends a VB event 
 with two strings that can be handled in the environment's programming language. For more information, use the keywords "Flash method" 
 to search the Flash Support Center at <xref href="http://www.adobe.com/support/flash/" scope="external">www.adobe.com/support/flash/</xref>.</p>
 <p><b>Note:</b> The ExternalInterface class provides better functionality
 for communication between JavaScript and ActionScript (Usage 2) and between ActionScript and VisualBasic, Visual C++, or other 
 programs that can host ActiveX controls (Usage 4). You should continue to use <codeph>fscommand()</codeph> for sending messages to Flash 
 Player (Usage 1) and Director (Usage 3).</p>
 
 </apiDesc><example conref="examples\FSCommandExample.as"> The following example shows how <codeph>fscommand()</codeph> can be used to direct
 Flash Player to go into full screen mode and not allow scaling.  An orange box is then
 added to the stage using <codeph>draw()</codeph>.  In <codeph>draw()</codeph>, a <codeph>click</codeph>
 event listener is added named <codeph>clickHandler()</codeph>, which responds to <codeph>click</codeph> 
 events by directing Flash Player to exit using another call to <codeph>fscommand().</codeph>
 
 <p><b>Note: </b> this example should be executed in the standalone Flash Player and
 not within a web browser.</p>
<codeblock>
package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.system.fscommand;
    import flash.events.MouseEvent;

    public class FSCommandExample extends Sprite {
        private var bgColor:uint = 0xFFCC00;
        private var size:uint = 100;

        public function FSCommandExample() {
            fscommand("fullscreen", "true");
            fscommand("allowscale", "false");
            draw();
        }

        private function clickHandler(event:MouseEvent):void {
            fscommand("quit");
            trace("clickHandler");
        }

        private function draw():void {
            var child:Sprite = new Sprite();
            child.graphics.beginFill(bgColor);
            child.graphics.drawRect(0, 0, size, size);
            child.graphics.endFill();
            child.buttonMode = true;
            addEventListener(MouseEvent.CLICK, clickHandler);

            var label:TextField = new TextField();
            label.text = "quit";
            label.selectable = false;
            label.mouseEnabled = false;
            child.addChild(label);

            addChild(child);
        }
    }
}
</codeblock></example></apiOperationDetail></apiOperation><apiClassifier id="flash.system:IME"><apiName>IME</apiName><shortdesc>
 The IME class lets you directly manipulate the operating system's input method 
 editor (IME) in the Flash Player application that is running on a client computer.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiTipTexts><apiTipText>Lets you directly manipulate the operating system's input method editor (IME).
 
 </apiTipText></apiTipTexts><apiBaseClassifier>flash.events:EventDispatcher</apiBaseClassifier></apiClassifierDef><apiDesc>
 The IME class lets you directly manipulate the operating system's input method 
 editor (IME) in the Flash Player application that is running on a client computer. You can 
 determine whether an IME is installed, whether or not the IME is currently enabled, and which IME is
 enabled. You can disable or enable the IME in the Flash Player application, and you can perform other limited
 functions, depending on the operating system.
 
 <p>IMEs let users type non-ASCII text characters in multibyte languages
 such as Chinese, Japanese, and Korean. For more information on working with IMEs, see the 
 documentation for the operating system for which you are developing applications.
 For additional resources, see the following websites:
 <ul>
   <li><xref href="http://www.microsoft.com/globaldev/default.mspx" scope="external">http://www.microsoft.com/globaldev/default.mspx</xref></li>
   <li><xref href="http://developer.apple.com/documentation/" scope="external">http://developer.apple.com/documentation/</xref></li>
   <li><xref href="http://java.sun.com" scope="external">http://java.sun.com</xref></li>
  </ul>
  </p>
 
 <p>If an IME is not active on the user's computer, calls to IME methods or properties, 
 other than <codeph>Capabilities.hasIME</codeph>, will fail. Once you manually activate an IME, subsequent ActionScript 
 calls to IME methods and properties will work as expected. For example, if you are using a
 Japanese IME, it must be activated before any IME method or property is called.</p>
 
 <p>The following table shows the platform coverage of this class:</p>
 
 
 <adobetable class="innertable">
  
 
 
 
  
  
 
  
  
 
 <tgroup cols="4"><thead><row><entry>Capability</entry><entry>Windows</entry><entry>Mac OSX</entry><entry>Linux</entry></row></thead><tbody><row>
    <entry>Determine whether the IME is installed: <codeph>Capabilities.hasIME</codeph></entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
  </row><row>
    <entry>Set IME on or off: <codeph>IME.enabled</codeph></entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
  </row><row>
    <entry>Find out whether IME is on or off: <codeph>IME.enabled</codeph></entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
    <entry>Yes</entry>
  </row><row>
    <entry>Get or set IME conversion mode: <codeph>IME.conversionMode</codeph></entry>
    <entry>Yes</entry>
    <entry>Yes ~~~~</entry>
    <entry>No</entry>
  </row><row>
    <entry>Send IME the string to be converted: <codeph>IME.setCompositionString()</codeph></entry>
    <entry>Yes ~~</entry>
    <entry>No</entry>
    <entry>No</entry>
  </row><row>
    <entry>Get from IME the original string before conversion: <codeph>System.ime.addEventListener()</codeph></entry>
    <entry>Yes ~~</entry>
    <entry>No</entry>
    <entry>No</entry>
  </row><row>
    <entry>Send request to convert to IME: <codeph>IME.doConversion()</codeph></entry>
    <entry>Yes ~~</entry>
    <entry>No</entry>
    <entry>No</entry>
  </row></tbody></tgroup></adobetable>
 
 <p>~~ Not all Windows IMEs support all of these operations. The only IME
 that supports them all is the Japanese IME.</p>
 
 <p>~~~~ On the Macintosh, only the Japanese IME supports these methods, and third-party IMEs do not support them.</p>
 <p>The ActionScript 3.0 version of this class does not support Macintosh Classic.</p>
 
 </apiDesc></apiClassifierDetail><adobeApiEvent id="flash.system:IME_flash.events.IMEEvent.IME_COMPOSITION_imeComposition"><apiName>imeComposition</apiName><shortdesc>
 Dispatched when a user has completed an 
 input method editor (IME) composition 
 and the reading string is available.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><adobeApiEventDetail><adobeApiEventDef><apiEventType>flash.events.IMEEvent.IME_COMPOSITION</apiEventType><adobeApiEventClassifier>flash.events.IMEEvent</adobeApiEventClassifier><apiGeneratedEvent/></adobeApiEventDef><apiDesc>
 Dispatched when a user has completed an 
 input method editor (IME) composition 
 and the reading string is available. 
 IMEs are generally used to enter text from languages that have ideographs instead 
 of letters, such as Japanese, Chinese and Korean.
 </apiDesc></adobeApiEventDetail></adobeApiEvent><apiOperation id="flash.system:IME:compositionAbandoned"><apiName>compositionAbandoned</apiName><shortdesc/><prolog/><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn></apiOperationDef></apiOperationDetail></apiOperation><apiOperation id="flash.system:IME:compositionSelectionChanged"><apiName>compositionSelectionChanged</apiName><shortdesc/><prolog/><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>start</apiItemName><apiOperationClassifier>int</apiOperationClassifier></apiParam><apiParam><apiItemName>end</apiItemName><apiOperationClassifier>int</apiOperationClassifier></apiParam></apiOperationDef></apiOperationDetail></apiOperation><apiOperation id="flash.system:IME:doConversion"><apiName>doConversion</apiName><shortdesc>
	 Instructs the IME to select the first candidate for the current composition string.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiException><apiDesc>The call was not successful.
	 </apiDesc><apiItemName>Error</apiItemName><apiOperationClassifier>Error</apiOperationClassifier></apiException><apiReturn><apiType value="void"/></apiReturn></apiOperationDef><apiDesc>
	 Instructs the IME to select the first candidate for the current composition string.
	 </apiDesc></apiOperationDetail></apiOperation><apiOperation id="flash.system:IME:setCompositionString"><apiName>setCompositionString</apiName><shortdesc>
	 Sets the IME composition string.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><internal>Need some examples of valid values for the param composition.
	 </internal></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiException><apiDesc>The call is not successful.
	 </apiDesc><apiItemName>Error</apiItemName><apiOperationClassifier>Error</apiOperationClassifier></apiException><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>composition</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>The string to send to the IME.
	 </apiDesc></apiParam></apiOperationDef><apiDesc>
	 Sets the IME composition string. When this string is set, the user 
	 can select IME candidates before committing the result to the text 
	 field that currently has focus.
	 <p>If no text field has focus, this method fails and throws an error.</p>
	 
	 </apiDesc></apiOperationDetail></apiOperation><apiValue id="flash.system:IME:conversionMode:get"><apiName>conversionMode</apiName><shortdesc>
	 The conversion mode of the current IME.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="readwrite"/><apiValueClassifier>String</apiValueClassifier><apiException><apiDesc>A set attempt was not successful.
	 </apiDesc><apiItemName>Error</apiItemName><apiOperationClassifier>Error</apiOperationClassifier></apiException></apiValueDef><apiDesc>
	 The conversion mode of the current IME.
	 Possible values are IME mode string constants that indicate the conversion mode:
	 <ul>
	 	<li><codeph>ALPHANUMERIC_FULL</codeph></li>
	 	<li><codeph>ALPHANUMERIC_HALF</codeph></li>
 	 	<li><codeph>CHINESE</codeph></li>
	 	<li><codeph>JAPANESE_HIRAGANA</codeph></li>
	 	<li><codeph>JAPANESE_KATAKANA_FULL</codeph></li>
	 	<li><codeph>JAPANESE_KATAKANA_HALF</codeph></li>
 	 	<li><codeph>KOREAN</codeph></li>
	  <li><codeph>UNKNOWN</codeph> (read-only value; this value cannot be set)</li>
	 </ul>
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IMEConversionMode/ALPHANUMERIC_FULL"><linktext>flash.system.IMEConversionMode.ALPHANUMERIC_FULL</linktext></link><link href="flash.system.xml#IMEConversionMode/ALPHANUMERIC_HALF"><linktext>flash.system.IMEConversionMode.ALPHANUMERIC_HALF</linktext></link><link href="flash.system.xml#IMEConversionMode/CHINESE"><linktext>flash.system.IMEConversionMode.CHINESE</linktext></link><link href="flash.system.xml#IMEConversionMode/JAPANESE_HIRAGANA"><linktext>flash.system.IMEConversionMode.JAPANESE_HIRAGANA</linktext></link><link href="flash.system.xml#IMEConversionMode/JAPANESE_KATAKANA_FULL"><linktext>flash.system.IMEConversionMode.JAPANESE_KATAKANA_FULL</linktext></link><link href="flash.system.xml#IMEConversionMode/JAPANESE_KATAKANA_HALF"><linktext>flash.system.IMEConversionMode.JAPANESE_KATAKANA_HALF</linktext></link><link href="flash.system.xml#IMEConversionMode/KOREAN"><linktext>flash.system.IMEConversionMode.KOREAN</linktext></link><link href="flash.system.xml#IMEConversionMode/UNKNOWN"><linktext>flash.system.IMEConversionMode.UNKNOWN</linktext></link></related-links></apiValue><apiValue id="flash.system:IME:enabled:get"><apiName>enabled</apiName><shortdesc>
	 Indicates whether the system IME is enabled (true) or disabled (false).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="readwrite"/><apiValueClassifier>Boolean</apiValueClassifier><apiException><apiDesc>A set attempt was not successful.
	 </apiDesc><apiItemName>Error</apiItemName><apiOperationClassifier>Error</apiOperationClassifier></apiException></apiValueDef><apiDesc>
	 Indicates whether the system IME is enabled (<codeph>true</codeph>) or disabled (<codeph>false</codeph>). 
	 An enabled IME performs multibyte input; a disabled IME performs alphanumeric input. 
	 </apiDesc></apiValueDetail></apiValue></apiClassifier><apiClassifier id="flash.system:System"><apiName>System</apiName><shortdesc>
 The System class contains properties related to certain operations that take place 
 on the user's computer, such as operations with shared 
 objects, local settings for cameras and microphones, and the use of the Clipboard.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>System, System object, built-in class
 </keyword></asCustoms></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiFinal/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
 The System class contains properties related to certain operations that take place 
 on the user's computer, such as <ph platform="actionscript">operations with shared 
 objects, local settings for cameras and microphones, and</ph> the use of the Clipboard.
 
 <p>Additional properties and methods are in other classes within the flash.system package:
 the Capabilities class, <ph platform="actionscript">the IME class,</ph> and the 
 Security class.</p>
 
 <p>This class contains only static methods and properties. You cannot 
 create new instances of the System class.</p>
 
 </apiDesc><example conref="examples\SystemExample.as"> The following example shows how to copy information about your system's total memory to the
 system Clipboard using a call to <codeph>System.totalMemory</codeph> within a call to the
 <codeph>System.setClipboard()</codeph> method.
<codeblock>
package {
    import flash.display.Sprite;
    import flash.system.System;

    public class SystemExample extends Sprite {
        public function SystemExample() {
            System.setClipboard("System.totalMemory: " + System.totalMemory);
        }
    }
}
</codeblock></example></apiClassifierDetail><related-links><link href="flash.system.xml#Security"><linktext>flash.system.Security</linktext></link><link href="flash.events.xml#IMEEvent"><linktext>flash.events.IMEEvent</linktext></link></related-links><apiOperation id="flash.system:System:disposeXML"><apiName>disposeXML</apiName><shortdesc>
	 Makes the specified XML object immediately available for garbage collection.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage name="ActionScript" version="3.0"/><apiPlatform description="" name="AIR" version="1.5.2"/></apiVersion></asMetadata></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>node</apiItemName><apiOperationClassifier>XML</apiOperationClassifier><apiDesc>XML reference that should be made available for garbage collection.
	 </apiDesc></apiParam></apiOperationDef><apiDesc>
	 Makes the specified XML object immediately available for garbage collection. 
	 This method will remove parent and child connections between all the nodes
	 for the specified XML node.
	 
	 </apiDesc></apiOperationDetail></apiOperation><apiOperation id="flash.system:System:exit"><apiName>exit</apiName><shortdesc> 
     Closes Flash Player.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage name="ActionScript" version="3.0"/><apiPlatform description="" name="Flash" version="9.0.115.0"/></apiVersion></asMetadata><asCustoms><keyword>System, System.exit(), exit()             
	 
	 </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>code</apiItemName><apiOperationClassifier>uint</apiOperationClassifier><apiDesc>A value to pass to the operating system. Typically, if
     the process exits normally, the value is 0.
	 
     </apiDesc></apiParam></apiOperationDef><apiDesc> 
     Closes Flash Player.
	 
     <p><i>For the standalone Flash Player debugger version only.</i></p> 
	 
     <p>AIR applications should call the <codeph>NativeApplication.exit()</codeph> method to exit the application.</p> 
	 
     </apiDesc></apiOperationDetail><related-links><link href="flash.desktop.xml#NativeApplication/exit()"><linktext>flash.desktop.NativeApplication.exit()</linktext></link></related-links></apiOperation><apiOperation id="flash.system:System:gc"><apiName>gc</apiName><shortdesc>
     Forces the garbage collection process.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage name="ActionScript" version="3.0"/><apiPlatform description="" name="Flash" version="9.0.115.0"/></apiVersion></asMetadata></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn></apiOperationDef><apiDesc>
     Forces the garbage collection process.
	 
     <p><ph platform="actionscript"><i>For the Flash Player debugger version and AIR applications only.</i></ph>
	 In an AIR application, the <codeph>System.gc()</codeph> method is only enabled in content running in the AIR Debug Launcher
	 (ADL) or, in an installed applcation, in content in the application security sandbox.</p>
	 
     </apiDesc></apiOperationDetail></apiOperation><apiOperation id="flash.system:System:pause"><apiName>pause</apiName><shortdesc> 
     Pauses Flash Player or the AIR Debug Launcher (ADL).</shortdesc><prolog><asMetadata><apiVersion><apiLanguage name="ActionScript" version="3.0"/><apiPlatform description="" name="Flash" version="9.0.115.0"/></apiVersion></asMetadata><asCustoms><keyword>System, System.pause(), pause()   
	 
	 </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn></apiOperationDef><apiDesc> 
     Pauses <ph platform="actionscript">Flash Player or</ph> the AIR Debug Launcher (ADL). 
	 After calling this method, nothing in the application continues except the delivery of Socket events.
	 
     <p platform="actionscript"><i>For the Flash Player debugger version or the AIR Debug Launcher (ADL) only.</i></p>
     
     </apiDesc></apiOperationDetail><related-links><link href="flash.system.xml#System/resume()"><linktext>resume()</linktext></link></related-links></apiOperation><apiOperation id="flash.system:System:resume"><apiName>resume</apiName><shortdesc> 
     Resumes the application after calling System.pause().</shortdesc><prolog><asMetadata><apiVersion><apiLanguage name="ActionScript" version="3.0"/><apiPlatform description="" name="Flash" version="9.0.115.0"/></apiVersion></asMetadata><asCustoms><keyword>System, System.resume(), resume()        
	 
	 </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn></apiOperationDef><apiDesc> 
     Resumes the application after calling <codeph>System.pause()</codeph>.
	 
     <p platform="actionscript"><i>For the Flash Player debugger version or the AIR Debug Launcher (ADL) only.</i></p>  
     
     </apiDesc></apiOperationDetail><related-links><link href="flash.system.xml#System/pause()"><linktext>pause()</linktext></link></related-links></apiOperation><apiOperation id="flash.system:System:setClipboard"><apiName>setClipboard</apiName><shortdesc>
	 Replaces the contents of the Clipboard with a specified text string.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>System.setClipboard, setClipboard
	 </keyword></asCustoms></prolog><apiOperationDetail><apiOperationDef><apiAccess value="public"/><apiStatic/><apiReturn><apiType value="void"/></apiReturn><apiParam><apiItemName>string</apiItemName><apiOperationClassifier>String</apiOperationClassifier><apiDesc>A plain-text string of characters to put on the system Clipboard, replacing its current contents (if any).
	 
	 
	 </apiDesc></apiParam><apiTipTexts><apiTipText>Replaces the contents of the Clipboard with a specified text string.
	 
	 </apiTipText></apiTipTexts></apiOperationDef><apiDesc>
	 Replaces the contents of the Clipboard with a specified text string. This method works from any security
	 context when called as a result of user event (such as a keyboard or mouse event handler).
	 
	 <p>This method is provided for SWF content running in Flash Player 9. It allows only adding 
	 String content to the Clipboard. Flash Player 10 content and content in the application 
	 security sandbox in an AIR application can call the <codeph>Clipboard.setData()</codeph>
	 method.</p>
	 
	 </apiDesc></apiOperationDetail><related-links><link href="flash.desktop.xml#Clipboard"><linktext>flash.desktop.Clipboard</linktext></link></related-links></apiOperation><apiValue id="flash.system:System:ime:get"><apiName>ime</apiName><shortdesc>
	 The currently installed system IME.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>flash.system:IME</apiValueClassifier></apiValueDef><apiDesc>
	 The currently installed system IME. 
	 To register for imeComposition events, call 
	 <codeph>addEventListener()</codeph> on this instance.
	 </apiDesc></apiValueDetail><related-links><link href="flash.system.xml#IMEConversionMode"><linktext>IMEConversionMode</linktext></link></related-links></apiValue><apiValue id="flash.system:System:totalMemory:get"><apiName>totalMemory</apiName><shortdesc>
     The amount of memory (in bytes) currently in use by Adobe&amp;#xAE; 
	 Flash&amp;#xAE; Player or Adobe&amp;#xAE; AIR&amp;#xAE;.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><internal>Add better description and example, unless private, in which case mark as "at"private.
	 </internal></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>uint</apiValueClassifier></apiValueDef><apiDesc>
     The amount of memory (in bytes) currently in use by <ph platform="actionscript">Adobe<sup>®</sup> 
	 Flash<sup>®</sup> Player or</ph> Adobe<sup>®</sup> AIR<sup>®</sup>.
	 
	 </apiDesc></apiValueDetail></apiValue><apiValue id="flash.system:System:useCodePage:get"><apiName>useCodePage</apiName><shortdesc>
	 A Boolean value that determines which code page to use to interpret external text files.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata><asCustoms><keyword>System.useCodepage, useCodepage, Unicode, code page
	 </keyword></asCustoms></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="readwrite"/><apiValueClassifier>Boolean</apiValueClassifier></apiValueDef><apiDesc>
	 A Boolean value that determines which code page to use to interpret external text files. 
	 When the property is set to <codeph>false</codeph>, external text files are interpretted as Unicode. 
	 (These files must be encoded as Unicode when you save them.) When the property is set to 
	 <codeph>true</codeph>, external text files are interpretted using the traditional code page of the 
	 operating system running the application. The default value of <codeph>useCodePage</codeph> is <codeph>false</codeph>.
	 
	 <p>Text that you load as an external file (using <codeph>Loader.load()</codeph>, the URLLoader class or
	 URLStream) must have been saved as Unicode in order for the application to recognize it 
	 as Unicode. To encode external files as Unicode, save the files in an application that 
	 supports Unicode, such as Notepad on Windows.</p>
	 
	 <p>If you load external text files that are not Unicode-encoded, set <codeph>useCodePage</codeph> to <codeph>true</codeph>. 
	 Add the following as the first line of code in the <ph product="flash"> first frame of the</ph> file that 
	 is loading the data:</p>
	 
	 <pre><codeph>System.useCodePage = true;</codeph></pre>
	 
	 <p>When this code is present, the application interprets external text 
	 using the traditional code page of the operating system. 
	 This is generally CP1252 for an English Windows operating 
	 system and Shift-JIS for a Japanese operating system. 
	 <ph platform="actionscript">If you set <codeph>useCodePage</codeph> to <codeph>true</codeph>, 
	 Flash Player 6 and later treat text as Flash Player 5 does. (Flash Player 5 
	 treated all text as if it were in the traditional code page of the operating 
	 system running the player.)</ph></p>
	 
	 <p>If you set <codeph>useCodePage</codeph> to <codeph>true</codeph>, remember that the 
	 traditional code page of the operating system running the application must include 
	 the characters used in your external text file in order to display your text. 
	 For example, if you load an external text file that contains Chinese characters, 
	 those characters cannot display on a system that uses the CP1252 code page because 
	 that code page does not include Chinese characters.</p>
	 
	 <p>To ensure that users on all platforms can view external text files used in your 
	 application, you should encode all external text files as Unicode and leave 
	 <codeph>useCodePage</codeph> set to <codeph>false</codeph>. This way, the application
	 <ph platform="actionscript">(Flash Player 6 and later)</ph> interprets the text as Unicode.</p>
	 
	 </apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link></related-links></apiValue></apiClassifier><apiClassifier id="flash.system:SecurityDomain"><apiName>SecurityDomain</apiName><shortdesc>
	The SecurityDomain class represents the current security "sandbox," also known as a security domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiClassifierDetail><apiClassifierDef><apiAccess value="public"/><apiStatic/><apiBaseClassifier>Object</apiBaseClassifier></apiClassifierDef><apiDesc>
	The SecurityDomain class represents the current security "sandbox," also known as a security domain.
	By passing an instance of this class to <codeph>Loader.load()</codeph>, you can request that loaded media be placed in
	a particular sandbox.
	</apiDesc></apiClassifierDetail><apiValue id="flash.system:SecurityDomain:currentDomain:get"><apiName>currentDomain</apiName><shortdesc>
		Gets the current security domain.</shortdesc><prolog><asMetadata><apiVersion><apiLanguage version="3.0"/><apiPlatform description="" name="Flash" version="9"/></apiVersion></asMetadata></prolog><apiValueDetail><apiValueDef><apiProperty/><apiAccess value="public"/><apiStatic/><apiValueAccess value="read"/><apiValueClassifier>flash.system:SecurityDomain</apiValueClassifier></apiValueDef><apiDesc>
		Gets the current security domain. 
		
		</apiDesc></apiValueDetail><related-links><link href="flash.display.xml#Loader/load()"><linktext>flash.display.Loader.load()</linktext></link><link href="flash.display.xml#Loader/loadBytes()"><linktext>flash.display.Loader.loadBytes()</linktext></link><link href="flash.system.xml#LoaderContext"><linktext>flash.system.LoaderContext</linktext></link></related-links></apiValue></apiClassifier></apiPackage>