DisplayObject  - AS3

De huidige toegankelijkheidsopties voor dit weergaveobject. Wanneer u de eigenschap accessibilityProperties of een van de velden binnen accessibilityProperties wijzigt, moet u de methode Accessibility.updateProperties() aanroepen om ervoor te zorgen dat uw wijzigingen van kracht worden.

Opmerking: voor een object dat in het Flash-ontwerpgereedschap is gemaakt, wordt de waarde van accessibilityProperties vooraf gevuld met informatie die u in het deelvenster Toegankelijkheid van dat object hebt ingevoerd.

Verwante API-elementen

import flash.text.TextField;
import flash.accessibility.AccessibilityProperties;
import flash.accessibility.Accessibility;
import flash.system.Capabilities;

var tf:TextField = new TextField();
tf.text = "hello";

var accessProps:AccessibilityProperties = new AccessibilityProperties();
accessProps.name = "Greeting";

tf.accessibilityProperties = accessProps;

if (Capabilities.hasAccessibility) {
    Accessibility.updateProperties();
}

trace(tf.accessibilityProperties.name); // Greeting

Geeft de alpha-transparantiewaarde van het opgegeven object aan. Geldige waarden zijn 0 (volledig transparant) tot en met 1 (volledig dekkend). De standaardwaarde is 1. Weergaveobjecten met alpha ingesteld op 0 zijn actief, ook al zijn ze onzichtbaar.

import flash.display.Sprite;
import flash.events.MouseEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFF0000);
circle.graphics.drawCircle(40, 40, 40);
addChild(circle);

circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject);
circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject);

function dimObject(event:MouseEvent):void {
    event.target.alpha = 0.5;
}

function restoreObject(event:MouseEvent):void {
    event.target.alpha = 1.0;
}

Een waarde uit de klasse BlendMode die opgeeft welke overvloeimodus moet worden gebruikt. Een bitmap kan intern op twee manieren worden getekend. Wanneer een overvloeimodus of een extern knipmasker is ingeschakeld, wordt de bitmap getekend door een rechthoek met bitmapvulling aan de vectorrendermodule toe te voegen. Wanneer u probeert om deze eigenschap op een ongeldige waarde in te stellen, stellen Flash-runtimes deze in op BlendMode.NORMAL.

De eigenschap blendMode betreft elke pixel van het weergaveobject. Elke pixel bestaat uit drie deelkleuren (rood, groen en blauw). Elke deelkleur heeft een waarde tussen 0x00 en 0xFF. Flash Player of Adobe AIR vergelijkt elke deelkleur van één pixel in de filmclip met de overeenkomende kleur van de pixel op de achtergrond. Als blendMode bijvoorbeeld op BlendMode.LIGHTEN is ingesteld, vergelijkt Flash Player of Adobe AIR de rode waarde van het weergaveobject met de rode waarde van de achtergrond en gebruikt de lichtere van de twee als de waarde voor de rode component van de weergegeven kleur.

In de volgende tabel worden de instellingen voor blendMode beschreven. De klasse BlendMode definieert tekenreekswaarden die u kunt gebruiken. De afbeeldingen in de tabel tonen hoe waarden blendMode zijn toegepast op een cirkelvormig weergaveobject (2) dat een ander weergaveobject op het scherm (1) overlapt.

Constante BlendMode	Afbeelding	Beschrijving
BlendMode.NORMAL		Het weergaveobject wordt vóór de achtergrond weergegeven. Pixelwaarden van het weergaveobject overschrijven de waarden van de achtergrond. Waar het weergaveobject transparant is, is de achtergrond zichtbaar.
BlendMode.LAYER		Dwingt het maken van een transparantiegroep voor het weergaveobject. Dit betekent dat het weergaveobject vooraf in een tijdelijke buffer wordt gemaakt voordat het verder wordt verwerkt. Dit gebeurt automatisch wanneer het weergaveobject van tevoren in cache wordt geplaatst via bitmapcaching of wanneer het weergaveobject een weergaveobjectcontainer is dat minstens één onderliggend object bevat waarvan blendMode een andere instelling heeft dan BlendMode.NORMAL. Niet ondersteund bij GPU-rendering.
BlendMode.MULTIPLY		Hiermee worden de waarden van de deelkleuren van het weergaveobject vermenigvuldigd met de kleuren van de achtergrondkleur en vervolgens genormaliseerd door te delen door 0xFF. Dit levert donkerdere kleuren op. Deze instelling wordt meestal voor schaduwen en diepte-effecten gebruikt. Wanneer een deelkleur (zoals rood) van één pixel in het weergaveobject en de overeenkomende kleur van de pixel op de achtergrond bijvoorbeeld beide de waarde 0x88 hebben, is het resultaat van de vermenigvuldiging 0x4840. Wanneer dit wordt gedeeld door 0xFF, levert dit de waarde 0x48 voor die deelkleur op. Dit is een donkerdere tint dan de kleur van het weergaveobject of de kleur van de achtergrond.
BlendMode.SCREEN		Vermenigvuldigt het complement (inverse waarde) van het weergaveobject met het complement van de achtergrondkleur. Dit levert lichtere kleuren op. Deze instelling wordt doorgaans gebruikt voor markeerkleuren of om zwarte gebieden uit het weergaveobject te verwijderen.
BlendMode.LIGHTEN		Hiermee worden de lichtste kleuren geselecteerd van de deelkleuren van het weergaveobject en de kleur van de achtergrond (de kleuren met de hoogste waarden). Deze instelling wordt meestal voor overlapping gebruikt. Wanneer het weergaveobject bijvoorbeeld een pixel met de RGB-waarde 0xFFCC33 heeft en de achtergrondpixel de RGB-waarde 0xDDF800 heeft, is de resulterende RGB-waarde voor de weergegeven pixel 0xFFF833 (aangezien 0xFF > 0xDD, 0xCC < 0xF8 en 0x33 > 0x00 = 33). Niet ondersteund bij GPU-rendering.
BlendMode.DARKEN		Selecteert de donkerdere deelkleuren van de deelkleuren van het weergaveobject en de achtergrondkleuren (de kleuren met de laagste waarden). Deze instelling wordt meestal voor overlapping gebruikt. Wanneer het weergaveobject bijvoorbeeld een pixel met de RGB-waarde 0xFFCC33 heeft en de achtergrondpixel de RGB-waarde 0xDDF800 heeft, is de resulterende RGB-waarde voor de weergegeven pixel 0xDDCC00 (aangezien 0xFF > 0xDD, 0xCC < 0xF8 en 0x33 > 0x00 = 33). Niet ondersteund bij GPU-rendering.
BlendMode.DIFFERENCE		Vergelijkt de deelkleuren van het weergaveobject met die van de achtergrondkleur en trekt de donkerdere waarde van de twee deelkleuren af van de lichtere waarde. Deze instelling wordt meestal gebruikt om levendiger kleuren te krijgen. Wanneer het weergaveobject bijvoorbeeld een pixel met de RGB-waarde 0xFFCC33 heeft en de achtergrondpixel de RGB-waarde 0xDDF800 heeft, is de resulterende RGB-waarde voor de weergegeven pixel 0x222C33 (aangezien 0xFF - 0xDD = 0x22, 0xF8 - 0xCC = 0x2C en 0x33 - 0x00 = 0x33).
BlendMode.ADD		Telt de waarden van de deelkleuren van het weergaveobject op bij die van de achtergrondkleuren, met een bovengrens van 0xFF. Deze instelling wordt meestal gebruikt voor animaties met een lichter makend overvloeiingseffect tussen twee objecten. Wanneer het weergaveobject bijvoorbeeld een pixel met de RGB-waarde 0xAAA633 heeft en de achtergrondpixel de RGB-waarde 0xDD2200 heeft, is de resulterende RGB-waarde voor de weergegeven pixel 0xFFC833 (aangezien 0xAA + 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8 en 0x33 + 0x00 = 0x33).
BlendMode.SUBTRACT		Trekt de waarden van de deelkleuren van het weergaveobject af van die van de achtergrondkleur, met een ondergrens van 0. Deze instelling wordt meestal gebruikt voor animaties met een donkerder makend overvloeiingseffect tussen twee objecten. Wanneer het weergaveobject bijvoorbeeld een pixel met de RGB-waarde 0xAA2233 heeft en de achtergrondpixel de RGB-waarde 0xDDA600 heeft, is de resulterende RGB-waarde voor de weergegeven pixel 0x338400 (aangezien 0xDD - 0xAA = 0x33, 0xA6 - 0x22 = 0x84 en 0x00 - 0x33 < 0x00).
BlendMode.INVERT		Hiermee wordt de achtergrond omgekeerd.
BlendMode.ALPHA		Past de alpha-waarde van elke pixel van het weergaveobject toe op de achtergrond. Hiervoor moet de instelling blendMode van het bovenliggende weergaveobject op BlendMode.LAYER worden ingesteld. In de afbeelding heeft het bovenliggende weergaveobject (een witte achtergrond) bijvoorbeeld blendMode = BlendMode.LAYER. Niet ondersteund bij GPU-rendering.
BlendMode.ERASE		Wist de achtergrond op basis van de alpha-waarde van het weergaveobject. Hiervoor moet de instelling blendMode van het bovenliggende weergaveobject op BlendMode.LAYER worden ingesteld. In de afbeelding heeft het bovenliggende weergaveobject (een witte achtergrond) bijvoorbeeld blendMode = BlendMode.LAYER. Niet ondersteund bij GPU-rendering.
BlendMode.OVERLAY		Past de kleur van elke pixel aan op basis van de donkerte van de achtergrond. Wanneer de achtergrond lichter dan 50% grijs is, worden de kleuren van het weergaveobject en de achtergrond gerasterd. Dit levert een lichtere kleur op. Wanneer de achtergrond donkerder dan 50% grijs is, worden de kleuren vermenigvuldigd. Dit levert een donkerdere kleur op. Deze instelling wordt meestal voor schaduweffecten gebruikt. Niet ondersteund bij GPU-rendering.
BlendMode.HARDLIGHT		Past de kleur van elke pixel aan op basis van de donkerte van het weergaveobject. Wanneer het weergaveobject lichter dan 50% grijs is, worden de kleuren van het weergaveobject en de achtergrond gerasterd. Dit levert een lichtere kleur op. Wanneer het weergaveobject donkerder dan 50% grijs is, worden de kleuren vermenigvuldigd. Dit levert een donkerdere kleur op. Deze instelling wordt meestal voor schaduweffecten gebruikt. Niet ondersteund bij GPU-rendering.
BlendMode.SHADER	N.v.t.	Past de kleur aan met een aangepaste arceringsroutine. De arcering die wordt gebruikt, wordt opgegeven als de Shader-instantie die is toegewezen aan de eigenschap blendShader. Als de eigenschap blendShader van een weergaveobject wordt ingesteld op een Shader-instantie, wordt automatisch de eigenschap blendMode van het weergaveobject ingesteld op BlendMode.SHADER. Als de eigenschap blendMode wordt ingesteld op BlendMode.SHADER zonder dat eerst de eigenschap blendShader is ingesteld, wordt de eigenschap blendMode ingesteld op BlendMode.NORMAL. Niet ondersteund bij GPU-rendering.

Verwante API-elementen

import flash.display.Sprite;
import flash.display.BlendMode;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF88CC);
square.graphics.drawRect(0, 0, 80, 80);
addChild(square);

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xAA0022);
circle.graphics.drawCircle(40, 40, 40);
addChild(circle);

circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject);
circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject);

function dimObject(event:MouseEvent):void {
    event.target.blendMode = BlendMode.SUBTRACT;
}

function restoreObject(event:MouseEvent):void {
    event.target.blendMode = BlendMode.NORMAL;
}

Stelt de arcering in die moet worden gebruikt om voor- en achtergrond in elkaar te laten overvloeien. Als de eigenschap blendMode is ingesteld op BlendMode.SHADER, wordt de opgegeven Shader gebruikt om de overvloeiingsmodusuitvoer voor het weergaveobject te maken.

Als de eigenschap blendShader van een weergaveobject wordt ingesteld op een Shader-instantie, wordt automatisch de eigenschap blendMode van het weergaveobject ingesteld op BlendMode.SHADER. Als de eigenschap blendShader wordt ingesteld (waarmee de eigenschap blendMode wordt ingesteld op BlendMode.SHADER), waarna later de waarde van de eigenschap blendMode wordt gewijzigd, kan de overvloeiingsmodus opnieuw worden ingesteld op het gebruik van de overvloeiingsarcering door de eigenschap blendMode in te stellen op BlendMode.SHADER. De eigenschap blendShader hoeft niet weer te worden ingesteld, behalve voor het wijzigen van de arcering die wordt gebruikt voor de overvloeiingsmodus.

De arcering die aan de eigenschap blendShader wordt toegewezen, moet minstens twee image4-invoeren opgeven. De invoeren hoeven niet in de code te worden opgegeven met de eigenschap input van het gekoppelde ShaderInput-object. Het achtergrondweergaveobject wordt automatisch gebruikt als de eerste invoer (de invoer met index 0). Het voorgrondweergaveobject wordt gebruikt als de tweede invoer (de invoer met index 1). Een arcering die wordt gebruikt als een overvloeiingsarcering, kan meer dan twee invoeren opgeven. In dat geval moet aanvullende invoer worden opgegeven door de eigenschap input van de ShaderInput-instantie in te stellen.

Als u een Shader-instantie toewijst aan deze eigenschap, wordt de arcering intern gekopieerd. De overvloeiingsbewerking gebruikt die interne kopie en geen verwijzing naar de oorspronkelijke arcering. Wijzigingen die worden aangebracht in de arcering, zoals een gewijzigde parameterwaarde, invoer of bytecode, worden niet toegepast op de gekopieerde arcering die wordt gebruikt voor de overvloeiingsmodus.

Verwante API-elementen

Indien ingesteld op true, plaatsen Flash-runtimes een interne bitmaprepresentatie van het weergaveobject in cache. Hierdoor kunnen de prestaties van weergaveobjecten worden verbeterd die complexe vectorinhoud bevatten.

Alle vectorgegevens van een weergaveobject dat een bitmap bevat die in cache is geplaatst, worden toegepast op de bitmap in plaats van op de hoofdweergave. Als cacheAsBitmapMatrix null is of ondersteund is, wordt de bitmap gekopieerd naar de hoofdweergave als niet-uitgerekte, niet-geroteerde pixels die op de dichtstbijzijnde pixelgrenzen worden uitgelijnd. Pixels worden een-op-een aan het bovenliggende object toegewezen. Wanneer de grenzen van de bitmap veranderen, wordt de bitmap opnieuw gemaakt in plaats van uitgerekt.

Als cacheAsBitmapMatrix niet null is en wordt ondersteund, wordt het object aan de hand van die matrix in de bitmap buiten het scherm getekend. De uitgerekte en/of geroteerde resultaten van die rendering worden gebruikt om het object in de hoofdweergave te tekenen.

Er wordt geen interne bitmap gemaakt, tenzij de eigenschap cacheAsBitmap op true is ingesteld.

Nadat u de eigenschap cacheAsBitmap op true hebt ingesteld, verandert de rendering niet. Er wordt echter automatisch magnetische pixeluitlijning voor het weergaveobject toegepast. De animatiesnelheid kan aanzienlijk worden verhoogd, afhankelijk van de complexiteit van de vectorinhoud.

De eigenschap cacheAsBitmap wordt automatisch op true ingesteld, wanneer u een filter op een weergaveobject toepast (wanneer de array filter niet leeg is) en wanneer een filter op het weergaveobject wordt toegepast, wordt cacheAsBitmap voor dat weergaveobject als true gerapporteerd, zelfs wanneer u de eigenschap op false instelt. Wanneer u alle filters voor een weergaveobject wist, wordt de instelling cacheAsBitmap gewijzigd in de waarde waarop deze voor het laatst was ingesteld.

In de volgende gevallen gebruikt een weergaveobject geen bitmap, zelfs niet wanneer de eigenschap cacheAsBitmap op true is ingesteld, maar wordt het weergaveobject op basis van vectorgegevens gerenderd:

• De bitmap is te groot. In AIR 1.5 en Flash Player 10 is de maximale grootte voor een bitmapafbeelding 8,191 pixels breed of hoog en mag het totale aantal pixels niet groter zijn dan 16,777,215 pixels. (Als een bitmapafbeelding 8,191 pixels breed is, kan deze daarom slechts 2048 pixels hoog zijn.) In Flash Player 9 en lager is de maximale hoogte 2880 pixels en de maximale breedte 2880 pixels.
• De bitmap kan niet worden toegewezen (fout als gevolg van onvoldoende geheugen).

De eigenschap cacheAsBitmap kan het best worden gebruikt met filmclips die voornamelijk statische inhoud bevatten en die niet regelmatig schalen of roteren. Met dergelijke filmclips kan cacheAsBitmap leiden tot prestatieverbeteringen wanneer de filmclip wordt getransleerd (wanneer de posities x en y worden gewijzigd).

Verwante API-elementen

import flash.display.Sprite;
import flash.filters.DropShadowFilter

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xAA0022);
circle.graphics.drawCircle(40, 40, 40);

addChild(circle);

trace(circle.cacheAsBitmap); // false

var filter:DropShadowFilter = new DropShadowFilter();
circle.filters = [filter];

trace(circle.cacheAsBitmap); // true

Als dit Matrix-object niet null is, definieert het hoe een weergaveobject wordt gerenderd als cacheAsBitmap wordt ingesteld op true. De toepassing gebruikt deze matrix als transformatiematrix die wordt toegepast bij het renderen van de bitmapversie van het weergaveobject.

AIR-profielondersteuning: Deze functie wordt ondersteund op mobiele apparaten, maar wordt niet ondersteund door desktopbesturingssystemen. Er is een beperkte ondersteuning bij AIR for TV-apparaten. Bij AIR for TV-apparaten worden de transformaties voor schaling en translatie wel ondersteund, maar niet voor roteren en schuintrekken. Zie AIR-profielondersteuning voor meer informatie over API-ondersteuning voor meerdere profielen.

Als cacheAsBitmapMatrix is ingesteld, behoudt de toepassing een in cache opgeslagen bitmapafbeelding tijdens verschillende 2D-transformaties, zoals translatie, rotatie en schaling. Als de toepassing hardwareversnelling gebruikt, wordt het object als textuur in het videogeheugen opgeslagen. Hierdoor kan de GPU de ondersteunde transformaties op het object toepassen. De GPU kan deze transformaties sneller uitvoeren dan de CPU.

Als u de hardwareversnelling wilt gebruiken, opent u het dialoogvenster iPhone-instellingen in Flash Professional CS5, selecteert u het tabblad Algemeen en stelt u Renderen in op GPU. U kunt ook de eigenschap renderMode op gpu instellen in het beschrijvingsbestand van de toepassing. Opmerking: AIR for TV-apparaten maken automatisch gebruik van hardwareversnelling, indien beschikbaar.

Met de volgende code wordt bijvoorbeeld een niet-getransformeerde bitmaprepresentatie van het weergaveobject naar de GPU verzonden:

matrix:Matrix = new Matrix(); // creates an identity matrix 
     mySprite.cacheAsBitmapMatrix = matrix; 
     mySprite.cacheAsBitmap = true;

Meestal voldoet de identiteitsmatrix (new Matrix()). U kunt echter ook een andere matrix gebruiken, bijvoorbeeld een geschaalde (verkleinde) matrix, om een andere bitmap naar de GPU te uploaden. In het volgende voorbeeld wordt een cacheAsBitmapMatrix-matrix toegepast die met 0,5 op de x- en y-as wordt geschaald. Het bitmapobject dat de GPU gebruikt is kleiner, maar de GPU stemt de grootte af op de eigenschap transform.matrix van het weergaveobject:

matrix:Matrix = new Matrix(); // creates an identity matrix 
     matrix.scale(0.5, 0.5); // scales the matrix 
     mySprite.cacheAsBitmapMatrix = matrix; 
     mySprite.cacheAsBitmap = true;

Over het algemeen kunt u het beste een matrix gebruiken die het weergaveobject transformeert tot de grootte die het in de toepassing krijgt. Als uw toepassing de bitmapversie van de sprite bijvoorbeeld met een half verkleind weergeeft, gebruikt u een matrix die met een half verkleint. Als uw toepassing de sprite vergroot weergeeft, gebruikt u een matrix die met de overeenkomstige factor vergroot.

Opmerking: de eigenschap cacheAsBitmapMatrix is geschikt voor 2D-transformaties. Als u transformaties in 3D wilt toepassen, kunt u dit doen door een 3D-eigenschap van het object in te stellen en de eigenschap transform.matrix3D van het object te manipuleren. Als de toepassing met de GPU-modus in een pakket is geplaatst, kunnen de 3D-transformaties door de GPU op het object worden toegepast. cacheAsBitmapMatrix wordt genegeerd voor 3D-objecten.

Verwante API-elementen

import flash.geom.Matrix;
import flash.display.*;
import flash.utils.Timer;

var my_shape:MovieClip = new MovieClip();
my_shape.graphics.beginFill(0xCCFF00);
my_shape.graphics.drawRect(200, 0, 100, 100);
addChild(my_shape);

var my_timer:Timer = new Timer(250);
my_timer.start();
my_timer.addEventListener(TimerEvent.TIMER, timerHandler);

// make sure this Display Object remains cached for all 2D transforms
my_shape.cacheAsBitmap = true;
my_shape.cacheAsBitmapMatrix = new Matrix();

// rotation variables
const initAngle:Number = 0;
const pi:Number = 3.142;
const incrAngle:Number = pi/10;

// scaling variables
const initScale:Number = 0.25;
const incrScale: Number = 1.1;
var initHeight : Number = my_shape.height;
var initWidth : Number = my_shape.width;

// translation variables
var incrX : Number = root.width / 20;
var incrY : Number = root.height / 10;

// do some initial transforms
var tempMat : Matrix = my_shape.transform.matrix;
tempMat.rotate(initAngle);
tempMat.scale(initScale, initScale);

my_shape.transform.matrix = tempMat;

function timerHandler(evt:TimerEvent):void {

    tempMat = my_shape.transform.matrix;
    
    tempMat.rotate(incrAngle);
    tempMat.translate(incrX, incrY);
    tempMat.scale(incrScale, incrScale);
    
    my_shape.transform.matrix = tempMat;
    
    // ensure we are still in a reasonable state or reset 
    if(my_shape.height > stage.stageHeight/2)
    {
        my_shape.height = initHeight;
    }
    
    if(my_shape.width > stage.stageWidth/2)
    {
        my_shape.width = initWidth;
    }
                              
    if(my_shape.x > stage.stageWidth)
    {
        my_shape.x = 0;
    }
    else if (my_shape.x < 0)
    {
        my_shape.x = stage.stageWidth;
    }

    
    if(my_shape.y > stage.stageHeight)
    {
        my_shape.y = 0;
    }
    else if (my_shape.y < 0)
    {
        my_shape.y = stage.stageHeight;
    }
    
}

Een geïndexeerde array die elk filterobject bevat dat momenteel is gekoppeld aan het weergaveobject. Het pakket flash.filters bevat een aantal klassen die specifieke filters definiëren die u kunt gebruiken.

Filters kunnen in Flash Professional worden toegepast tijdens het ontwerpen of in runtime met gebruikmaking van ActionScript-code. Wanneer u een filter met ActionScript wilt toepassen, moet u een tijdelijke kopie van de gehele array filters maken, de tijdelijke array wijzigen en vervolgens de waarde van de tijdelijke array weer aan de array filters toewijzen. U kunt niet rechtstreeks een nieuw filterobject aan de array filters toewijzen.

Wanneer u een filter wilt toevoegen met ActionScript, moet u de volgende stappen uitvoeren (ervan uitgaande dat het doelweergaveobject de naam myDisplayObject heeft):

1. Maak een nieuw filterobject met de constructormethode van de gewenste filterklasse.
2. Wijs de waarde van de array myDisplayObject.filters toe aan een tijdelijke array, zoals een array met de naam myFilters.
3. Voeg het nieuwe filterobject toe aan de tijdelijke array myFilters.
4. Wijs de waarde van de tijdelijke array toe aan de array myDisplayObject.filters.

Wanneer de array filters niet is gedefinieerd, hoeft u geen tijdelijke array te gebruiken. In plaats daarvan kunt u rechtstreeks een letterlijk arrayteken toewijzen dat een of meer filterobjecten bevat die u hebt gemaakt. In het eerste voorbeeld van de sectie Voorbeelden wordt een slagschaduwfilter toegevoegd met code die zowel gedefinieerde als niet-gedefinieerde arrays filters verwerkt.

Wanneer u een bestaand filterobject wilt wijzigen, moet u een kopie van de array filters wijzigen:

1. Wijs de waarde van de array filters toe aan een tijdelijke array, zoals een array met de naam myFilters.
2. Wijzig de eigenschap met gebruikmaking van de tijdelijke array myFilters. Wanneer u bijvoorbeeld de eigenschap quality van het eerste filter in de array wilt instellen, zou u de volgende code kunnen gebruiken: myFilters[0].quality = 1;
3. Wijs de waarde van de tijdelijke array toe aan de array filters.

Wanneer een weergaveobject tijdens laadtijd een gekoppeld filter heeft, wordt deze gemarkeerd om zichzelf als transparante bitmap in cache te plaatsen. Vanaf dit punt plaatst de speler, zolang het weergaveobject een geldige filterlijst heeft, het weergaveobject als een bitmap in cache. Deze bronbitmap wordt gebruikt als een bronafbeelding voor de filtereffecten. Elk weergaveobject heeft gewoonlijk twee bitmappen: een bitmap met het oorspronkelijk ongefilterde bronweergaveobject en een bitmap voor de uiteindelijke afbeelding na filtering. De uiteindelijke afbeelding wordt voor rendering gebruikt. Zolang het weergaveobject niet wordt gewijzigd, hoeft de uiteindelijke afbeelding niet te worden bijgewerkt.

Het pakket flash.filters bevat klassen voor filters. Wanneer u bijvoorbeeld een filter DropShadow wilt maken, gebruikt u de volgende code:

     import flash.filters.DropShadowFilter
     var myFilter:DropShadowFilter = new DropShadowFilter (distance, angle, color, alpha, blurX, blurY, quality, inner, knockout)
     

U kunt de operator is gebruiken om het type filter te bepalen dat aan elke indexpositie is toegewezen in de array filter. De volgende code geeft bijvoorbeeld weer hoe u de positie van het eerste filter moet bepalen in de array filters dat een DropShadowFilter is:

     import flash.text.TextField;
     import flash.filters.*;
     var tf:TextField = new TextField();
     var filter1:DropShadowFilter = new DropShadowFilter();
     var filter2:GradientGlowFilter = new GradientGlowFilter();
     tf.filters = [filter1, filter2];
     
     tf.text = "DropShadow index: " + filterPosition(tf, DropShadowFilter).toString(); // 0
     addChild(tf)
     
     function filterPosition(displayObject:DisplayObject, filterClass:Class):int {
         for (var i:uint = 0; i < displayObject.filters.length; i++) {
             if (displayObject.filters[i] is filterClass) {
                 return i;
             }
         }
         return -1;
     }
     

Opmerking: omdat u niet rechtstreeks een nieuw filterobject aan de array DisplayObject.filters kunt toevoegen, heeft de volgende code geen invloed op het doelweergaveobject met de naam myDisplayObject:

     myDisplayObject.filters.push(myDropShadow);
     

Verwante API-elementen

Geeft de hoogte van het weergaveobject aan, in pixels. De hoogte wordt berekend op basis van de grenzen van de inhoud van het weergaveobject. Wanneer u de eigenschap height instelt, wordt de eigenschap scaleY overeenkomstig aangepast, zoals in de volgende code wordt getoond:

    var rect:Shape = new Shape();
    rect.graphics.beginFill(0xFF0000);
    rect.graphics.drawRect(0, 0, 100, 100);
    trace(rect.scaleY) // 1;
    rect.height = 200;
    trace(rect.scaleY) // 2;

Met uitzondering van de objecten TextField en Video, heeft een weergaveobject zonder inhoud (zoals een lege sprite) een hoogte van 0, ook als u probeert height op een andere waarde in te stellen.

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.wordWrap = true;
tf1.width = 40;
tf1.height = tf1.textHeight + 5;
addChild(tf1);

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.wordWrap = true;
tf2.width = 40;
tf2.height = tf2.textHeight + 5;
tf2.y = tf1.y + tf1.height + 5;
addChild(tf2);

Retourneert een object LoaderInfo dat informatie bevat over het laden van het bestand waartoe dit weergaveobject behoort. De eigenschap loaderInfo wordt alleen gedefinieerd voor het hoofdweergaveobject van een SWF-bestand of voor een geladen bitmap (geen bitmap die met ActionScript is getekend). Wanneer u het object loaderInfo wilt zoeken dat aan het SWF-bestand is gekoppeld dat een weergaveobject met de naam myDisplayObject bevat, moet u myDisplayObject.root.loaderInfo gebruiken.

Een groot SWF-bestand kan de download controleren door this.root.loaderInfo.addEventListener(Event.COMPLETE, func) aan te roepen.

Verwante API-elementen

 trace (this.loaderInfo.url);
 

Het aanroepende weergaveobject wordt gemaskeerd door het opgegeven object mask. Het weergaveobject mask moet zich in een actief gedeelte van het weergaveoverzicht bevinden om te zorgen dat maskering werkt wanneer het werkgebied wordt geschaald. Het object mask zelf wordt niet getekend. Stel mask in op null om het masker te verwijderen.

Wanneer u een object mask wilt schalen, moet het zich in het weergaveoverzicht bevinden. Wanneer u een Sprite-object mask wilt slepen (door de methode startDrag() aan te roepen), moet het zich in het weergaveoverzicht bevinden. Wanneer u de methode startDrag() wilt aanroepen voor een maskeersprite die is gebaseerd op een gebeurtenis mouseDown die door de sprite wordt verzonden, stelt u de eigenschap buttonMode van de sprite op true in.

Wanneer weergaveobjecten in de cache worden opgeslagen doordat u de eigenschap cacheAsBitmap hebt ingesteld op true en de eigenschap cacheAsBitmapMatrix op een Matrix-object, moeten zowel het masker als het te maskeren weergaveobject onderdeel zijn van dezelfde bitmap die in de cache is opgeslagen. Als het weergaveobject in de cache wordt opgeslagen, moet het masker daarom een onderliggend element zijn van het weergaveobject. Als een voorouder van het weergaveobject in het weergaveoverzicht in de cache wordt opgeslagen, moet het masker een onderliggend element van die voorouder of van een van zijn afstammelingen zijn. Als meerdere voorouders van het gemaskeerde object in de cache wordt opgeslagen, moet het masker een afstamming zijn van de container in de cache die het dichtst bij het gemaskeerde object in het weergaveoverzicht staat.

Opmerking: Een enkel mask-object kan niet worden gebruikt om meerdere aanroepende weergaveobjecten te maskeren. Wanneer het mask aan een tweede weergaveobject wordt toegewezen, wordt het als masker van het eerste object verwijderd, en krijgt de eigenschap mask van dat object de waarde null.

import flash.text.TextField;
import flash.display.Sprite;
import flash.events.MouseEvent;

var tf:TextField = new TextField();
tf.text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " 
            + "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
tf.selectable = false;
tf.wordWrap = true;
tf.width = 150;
addChild(tf);

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 40, 40);
addChild(square);

tf.mask = square;

tf.addEventListener(MouseEvent.MOUSE_DOWN, drag);
tf.addEventListener(MouseEvent.MOUSE_UP, noDrag);

function drag(event:MouseEvent):void {
    square.startDrag();
}
function noDrag(event:MouseEvent):void {
    square.stopDrag();
}

Krijgt het metagegevensobject van de DisplayObject-instantie als de metagegevens zijn opgeslagen naast de instantie van dit DisplayObject in het SWF-bestand door een PlaceObject4-markering.

Geeft de x-coördinaat van de apparaatpositie van de muis of de gebruikersinvoer aan in pixels.

Opmerking: In het geval van een geroteerd DisplayObject vertegenwoordigt de geretourneerde x-coördinaat het niet-geroteerde object.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 200, 200);
addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

function traceCoordinates(event:MouseEvent):void {
    trace(square.mouseX, square.mouseY);
}

Geeft de y-coördinaat van de apparaatpositie van de muis of de gebruikersinvoer aan in pixels.

Opmerking: In het geval van een geroteerd DisplayObject vertegenwoordigt de geretourneerde y-coördinaat het niet-geroteerde object.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 200, 200);
addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

function traceCoordinates(event:MouseEvent):void {
    trace(square.mouseX, square.mouseY);
}

Geeft de instantienaam van het DisplayObject aan. U kunt het object in de onderliggende lijst van de bovenliggende weergaveobjectcontainer identificeren met de methode getChildByName() van de weergaveobjectcontainer.

import flash.display.Sprite;
import flash.events.MouseEvent;

var circle1:Sprite = new Sprite();
circle1.graphics.beginFill(0xFF0000);
circle1.graphics.drawCircle(40, 40, 40);
circle1.name = "circle1";
addChild(circle1);
circle1.addEventListener(MouseEvent.CLICK, traceName);

var circle2:Sprite = new Sprite();
circle2.graphics.beginFill(0x0000FF);
circle2.graphics.drawCircle(140, 40, 40);
circle2.name = "circle2";
addChild(circle2);
circle2.addEventListener(MouseEvent.CLICK, traceName);

function traceName(event:MouseEvent):void {
    trace(event.target.name);
}

Geeft op of het weergaveobject dekkend is met een bepaalde achtergrondkleur. Een transparante bitmap bevat alpha-kanaalgegevens en wordt transparant getekend. Een dekkende bitmap bevat geen alpha-kanaal (en wordt sneller gerenderd dan een transparante bitmap). Wanneer de bitmap dekkend is, geeft u de achtergrondkleur op.

Indien ingesteld op een getalswaarde, is het oppervlak dekkend (niet transparant) met de RGB-achtergrondkleur die door het getal wordt opgegeven. Indien ingesteld op null (standaardwaarde), heeft het weergaveobject een transparante achtergrond.

De eigenschap opaqueBackground is hoofdzakelijk bedoeld voor gebruik met de eigenschap cacheAsBitmap voor optimalisatie van de rendering. Voor weergaveobjecten waarin de eigenschap cacheAsBitmap op true is ingesteld, kunt u de renderingprestaties verbeteren door opaqueBackground in te stellen.

De dekkende achtergrond komt niet overeen wanneer u de methode hitTestPoint() aanroept met de parametershapeFlag ingesteld op true.

Het dekkende achtergrondgebied reageert niet op muisgebeurtenissen.

Verwante API-elementen

import flash.display.Shape;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.opaqueBackground = 0xFF0000;
addChild(circle);

Geeft het object DisplayObjectContainer aan dat dit weergaveobject bevat. Gebruik de eigenschap parent om een relatief pad naar weergaveobjecten op te geven die boven het huidige weergaveobject in de weergaveoverzichthiërarchie staan.

U kunt parent gebruiken om meerdere niveaus in het weergaveoverzicht omhoog te gaan:

     this.parent.parent.alpha = 20;
     

import flash.display.Sprite;

var sprite1:Sprite = new Sprite();
sprite1.name = "sprite1";
var sprite2:Sprite = new Sprite();
sprite2.name = "sprite2";
var sprite3:Sprite = new Sprite();
sprite3.name = "sprite3";

sprite1.addChild(sprite2);
sprite2.addChild(sprite3);

trace(sprite2.parent.name); // sprite1
trace(sprite3.parent.name); // sprite2
trace(sprite3.parent.parent.name); // sprite1

Voor een weergaveobject in een geladen SWF-bestand is de eigenschap root het bovenste weergaveobject in het gedeelte van de boomstructuur van het weergaveoverzicht dat wordt vertegenwoordigd door dat SWF-bestand. Voor een object Bitmap dat een geladen afbeeldingsbestand vertegenwoordigt, is de eigenschap root het object Bitmap zelf. Voor de instantie van de hoofdklasse van het SWF-bestand dat als eerste is geladen, is de eigenschap root het weergaveobject zelf. De eigenschap root van het object Stage is het object Stage zelf. De eigenschap root is op null ingesteld voor elk weergaveobject dat niet aan het weergaveoverzicht is toegevoegd, tenzij het aan de weergaveobjectcontainer is toegevoegd die niet in het weergaveoverzicht staat, maar een onderliggend item is van het bovenste weergaveobject in een geladen SWF-bestand.

Wanneer u bijvoorbeeld een nieuw object Sprite maakt door de constructormethode Sprite() aan te roepen, is de eigenschap root null totdat u het aan het weergaveoverzicht toevoegt (of aan een weergaveobjectcontainer die niet in het weergaveoverzicht staat maar een onderliggend item is van het bovenste weergaveobject in een SWF-bestand).

Voor een geladen SWF-bestand is de eigenschap root op zichzelf ingesteld, ook al staat het object Loader dat is gebruikt om het bestand te laden, mogelijk niet in het weergaveoverzicht. De eigenschap root van het object Loader wordt pas ingesteld nadat het is toegevoegd als een onderliggend item van een weergaveobject waarvoor de eigenschap root is ingesteld.

import flash.display.Loader;
import flash.net.URLRequest;
import flash.events.Event;

trace(stage.root); // [object Stage]

var ldr:Loader = new Loader();
trace (ldr.root); // null

addChild(ldr); 
trace (ldr.root); // [object ...]

var urlReq:URLRequest = new URLRequest("example.jpg");
ldr.load(urlReq);

ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, loaded);

function loaded(event:Event):void {
    trace(ldr.content.root); // [object Bitmap]
}

Geeft de rotatie van de instantie DisplayObject vanaf de oorspronkelijke oriëntatie (in graden) aan. Waarden tussen 0 en 180 geven rotatie met de klok mee aan; waarden tussen 0 en -180 geven rotatie tegen de klok in aan. Waarden buiten dit bereik worden opgeteld bij of afgetrokken van 360 om een waarde binnen het bereik te verkrijgen. De instructie my_video.rotation = 450 is bijvoorbeeld gelijk aan de instructie my_video.rotation = 90.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(-50, -50, 100, 100);
square.x = 150;
square.y = 150;
addChild(square);

square.addEventListener(MouseEvent.CLICK, rotate);

function rotate(event:MouseEvent):void {
        square.rotation += 15;
}

Geeft in graden de X-asrotatie van de DisplayObject-instantie aan ten opzichte van de 3D parent-container. Waarden tussen 0 en 180 geven rotatie met de klok mee aan; waarden tussen 0 en -180 geven rotatie tegen de klok in aan. Waarden buiten dit bereik worden opgeteld bij of afgetrokken van 360 om een waarde binnen het bereik te verkrijgen.

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.display.Graphics;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class RotationExample1 extends MovieClip {
        private var ellipse:Shape = new Shape();
        private var speed:int = 10;
        private var ellipse1:Shape;
        private var ellipse2:Shape;
        
        public function RotationExample1():void {

            ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), 
                                    (this.stage.stageHeight / 2));
            
            ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), 
                                          (this.stage.stageHeight / 2));

            this.addChild(ellipse1);
            this.addChild(ellipse2);

            var t:Timer = new Timer(50);
            t.addEventListener(TimerEvent.TIMER, timerHandler);
            t.start();
        }

        private function drawEllipse(x1, y1, x2, y2):Shape {
        
            var e:Shape = new Shape();
            e.graphics.beginFill(0xFF0000);
            e.graphics.lineStyle(2);
            e.graphics.drawEllipse(x1, y1, 100, 80);
            e.graphics.endFill();

            e.x  = x2;  
            e.y  = y2;
            e.z = 1;
            return e;
        }

        private function timerHandler(event:TimerEvent):void {
            ellipse1.rotationY += speed;    
            ellipse1.rotationX -= speed;

            ellipse2.rotationY += speed;    
            ellipse2.rotationX -= speed;
        }
    }
}

//Requires:
//  - Slider control UI component in Flash library.
//  - Publish for Flash Player 10.
//
 
[SWF(width="400", height="300")]
 
import fl.controls.Slider;
import fl.controls.SliderDirection;
import fl.events.SliderEvent;
 
var slider:Slider = new Slider();
slider.direction = SliderDirection.HORIZONTAL;
slider.minimum = 0;
slider.maximum = 360;
slider.value = 45;
slider.tickInterval = 45;
slider.snapInterval = 1;
slider.liveDragging = true;
slider.addEventListener(SliderEvent.CHANGE, slider_change);
slider.move(10, 10);
addChild(slider);
 
var spr:Sprite = new Sprite();
spr.graphics.lineStyle(2, 0xFF0000);
spr.graphics.drawRect(0, 0, 100, 80);
spr.x = Math.round((stage.stageWidth - spr.width)/2);
spr.y = Math.round((stage.stageHeight - spr.height)/2);
spr.rotationX = 45;
addChild(spr);
 
function slider_change(evt:SliderEvent):void {
    spr.rotationX = evt.value;
}

Geeft in graden de y-asrotatie van de DisplayObject-instantie aan ten opzichte van de 3D parent-container. Waarden tussen 0 en 180 geven rotatie met de klok mee aan; waarden tussen 0 en -180 geven rotatie tegen de klok in aan. Waarden buiten dit bereik worden opgeteld bij of afgetrokken van 360 om een waarde binnen het bereik te verkrijgen.

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.display.Graphics;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class RotationExample1 extends MovieClip {
        private var ellipse:Shape = new Shape();
        private var speed:int = 10;
        private var ellipse1:Shape;
        private var ellipse2:Shape;
        
        public function RotationExample1():void {

            ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), 
                                    (this.stage.stageHeight / 2));
            
            ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), 
                                          (this.stage.stageHeight / 2));

            this.addChild(ellipse1);
            this.addChild(ellipse2);

            var t:Timer = new Timer(50);
            t.addEventListener(TimerEvent.TIMER, timerHandler);
            t.start();
        }

        private function drawEllipse(x1, y1, x2, y2):Shape {
        
            var e:Shape = new Shape();
            e.graphics.beginFill(0xFF0000);
            e.graphics.lineStyle(2);
            e.graphics.drawEllipse(x1, y1, 100, 80);
            e.graphics.endFill();

            e.x  = x2;  
            e.y  = y2;
            e.z = 1;
            return e;
        }

        private function timerHandler(event:TimerEvent):void {
            ellipse1.rotationY += speed;    
            ellipse1.rotationX -= speed;

            ellipse2.rotationY += speed;    
            ellipse2.rotationX -= speed;
        }
    }
}

Geeft in graden de z-asrotatie van de DisplayObject-instantie aan ten opzichte van de 3D parent-container. Waarden tussen 0 en 180 geven rotatie met de klok mee aan; waarden tussen 0 en -180 geven rotatie tegen de klok in aan. Waarden buiten dit bereik worden opgeteld bij of afgetrokken van 360 om een waarde binnen het bereik te verkrijgen.

Het huidige schaalraster dat wordt gebruikt. Wanneer dit op null is ingesteld, wordt het gehele weergaveobject normaal geschaald wanneer schaaltransformatie wordt toegepast.

Wanneer u een eigenschap scale9Grid definieert, wordt het weergaveobject verdeeld in een raster met negen gebieden die zijn gebaseerd op de rechthoek scale9Grid, die het middengebied van het raster definieert. De andere acht gebieden van het raster zijn:

• De linkerbovenhoek buiten de rechthoek.
• Het gebied boven de rechthoek.
• De rechterbovenhoek buiten de rechthoek.
• Het gebied links van de rechthoek.
• Het gebied rechts van de rechthoek.
• De linkerbenedenhoek buiten de rechthoek.
• Het gebied onder de rechthoek.
• De rechterbenedenhoek buiten de rechthoek.

U kunt de acht gebieden buiten het midden (gedefinieerd door de rechthoek) beschouwen als een soort schilderijlijst waarop speciale regels worden toegepast wanneer het weergaveobject wordt geschaald.

Wanneer de eigenschap scale9Grid wordt ingesteld en een weergaveobject wordt geschaald, worden alle tekst en verlopen normaal geschaald; voor andere objecttypen gelden echter de volgende regels:

• Inhoud in het middengebied wordt normaal geschaald.
• Inhoud in de hoeken wordt niet geschaald.
• Inhoud in de boven- en ondergebieden wordt alleen horizontaal geschaald. Inhoud in de linker- en rechtergebieden wordt alleen verticaal geschaald.
• Alle vullingen (inclusief bitmaps, video en verlopen) worden uitgerekt om hun vormen te vullen.

Wanneer een weergaveobject wordt geroteerd, is daaropvolgende schaling normaal (en wordt de eigenschap scale9Grid genegeerd).

Neem bijvoorbeeld het volgende weergaveobject en een rechthoek die als de eigenschap scale9Grid van het weergaveobject wordt toegepast:

Het weergaveobject.

De rode rechthoek geeft scale9Grid weer.

Wanneer het weergaveobject wordt geschaald of uitgerekt, worden de objecten in de rechthoek normaal geschaald, maar worden de objecten buiten de rechthoek op basis van de scale9Grid-regels geschaald:

Geschaald tot 75%:
Geschaald tot 50%:
Geschaald tot 25%:
Horizontaal 150% uitgerekt:

De instelling scale9Grid wordt veel gebruikt om een weergaveobject als een component te gebruiken, waarin randlijnen dezelfde dikte behouden wanneer de component wordt geschaald.

Verwante API-elementen

import flash.display.Shape;
import flash.display.GradientType;
import flash.display.SpreadMethod;
import flash.display.InterpolationMethod;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.utils.Timer;
import flash.events.TimerEvent;

var square:Shape = new Shape();
square.graphics.lineStyle(20, 0xFFCC00);
var gradientMatrix:Matrix = new Matrix();
gradientMatrix.createGradientBox(15, 15, Math.PI, 10, 10);
square.graphics.beginGradientFill(GradientType.RADIAL, 
            [0xffff00, 0x0000ff], 
            [100, 100], 
            [0, 0xFF], 
            gradientMatrix, 
            SpreadMethod.REFLECT, 
            InterpolationMethod.RGB, 
            0.9);
square.graphics.drawRect(0, 0, 100, 100);

var grid:Rectangle = new Rectangle(20, 20, 60, 60);
square.scale9Grid = grid ;

addChild(square);

var tim:Timer = new Timer(100);
tim.start();
tim.addEventListener(TimerEvent.TIMER, scale);

var scaleFactor:Number = 1.01;

function scale(event:TimerEvent):void {
    square.scaleX *= scaleFactor;
    square.scaleY *= scaleFactor;
    
    if (square.scaleX > 2.0) {
        scaleFactor = 0.99;
    }
    if (square.scaleX < 1.0) {
        scaleFactor = 1.01;
    }
}

Bepaalt de horizontale schaal (percentage) van het object zoals deze wordt toegepast vanuit het registratiepunt. Het standaardregistratiepunt is (0,0). 1,0 is gelijk aan een schaal van 100%.

Wanneer het lokale coördinatensysteem wordt geschaald, veranderen de waarden van de eigenschappen x en y, die in hele pixels worden gedefinieerd.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, scale);

function scale(event:MouseEvent):void {
    square.scaleX *= 1.10;
    square.scaleY *= 1.10;
}

Bepaalt de verticale schaal (percentage) van een object zoals deze wordt toegepast vanuit het registratiepunt van het object. Het standaardregistratiepunt is (0,0). 1,0 is een schaal van 100%.

Wanneer het lokale coördinatensysteem wordt geschaald, veranderen de waarden van de eigenschappen x en y, die in hele pixels worden gedefinieerd.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, scale);

function scale(event:MouseEvent):void {
    square.scaleX *= 1.10;
    square.scaleY *= 1.10;
}

Bepaalt de diepteschaal (percentage) van een object zoals deze wordt toegepast vanuit het registratiepunt van het object. Het standaardregistratiepunt is (0,0). 1,0 is een schaal van 100%.

Wanneer het lokale coördinatensysteem wordt geschaald, veranderen de waarden van de eigenschappen x, y en z die in hele pixels worden gedefinieerd.

Verwante API-elementen

De verschuivende rechthoekgrenzen van het weergaveobject. Het weergaveobject wordt tot een grootte uitgesneden die door de rechthoek wordt gedefinieerd en wordt binnen de rechthoek geschoven wanneer u de eigenschappen x en y van het object scrollRect wijzigt.

De eigenschappen van het Rectangle-object scrollRect gebruiken de coördinaatruimte van het weergaveobject en worden zoals het algemene weergaveobject geschaald. De hoekgrenzen van het bijgesneden venster van het schuivende weergaveobject zijn de oorsprong van het weergaveobject (0,0) en het punt dat door de breedte en de hoogte van de rechthoek wordt gedefinieerd. Deze punten worden niet rondom de oorsprong gecentreerd, maar gebruiken de oorsprong om de linkerbovenhoek te definiëren. Een schuivend weergaveobject schuift altijd met hele pixelstappen.

U kunt een object naar links en naar rechts schuiven door de eigenschap x van het object Rectangle scrollRect in te stellen. U kunt een object omhoog en omlaag schuiven door de eigenschap y van het object Rectangle scrollRect in te stellen. Wanneer het weergaveobject 90 graden wordt geroteerd en u deze naar links en rechts schuift, schuift het weergaveobject omhoog en omlaag.

Merk op dat de wijzigingen in de eigenschap scrollRect alleen worden verwerkt wanneer het object wordt gerenderd. Om deze reden krijgt u misschien niet het gewenste resultaat als u een methode zoals localToGlobal direct aanroept nadat u scrollRect hebt gewijzigd.

Opmerking: vanaf Flash Player 11.4/AIR 3.4 zijn negatieve waarden voor de breedte of de hoogte van de rechthoek gewijzigd in 0.

Verwante API-elementen

import flash.display.Sprite;
import flash.geom.Rectangle;
import flash.events.MouseEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFFCC00);
circle.graphics.drawCircle(200, 200, 200);
circle.scrollRect = new Rectangle(0, 0, 200, 200);
addChild(circle);

circle.addEventListener(MouseEvent.CLICK, clicked);

function clicked(event:MouseEvent):void {
    var rect:Rectangle = event.target.scrollRect;
    rect.y -= 5;
    event.target.scrollRect = rect;
}

Het werkgebied van het weergaveobject. Een Flash-runtimetoepassing bevat slechts één Stage-object. U kunt bijvoorbeeld meerdere weergaveobjecten in het weergaveoverzicht maken en laden, terwijl de eigenschap stage van elk weergaveobject naar hetzelfde object Stage verwijst (zelfs wanneer het weergaveobject bij een geladen SWF-bestand hoort).

Wanneer het weergaveobject niet aan het weergaveoverzicht wordt toegevoegd, wordt de eigenschap stage op null ingesteld.

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.x = 10;
addChild(tf1);
tf1.width = tf1.stage.stageWidth / 2 - 10;

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.x = tf1.x + tf1.width + 5;
addChild(tf2);
tf2.width = tf2.stage.stageWidth / 2 - 10;

trace(stage.stageWidth);

Een object met eigenschappen die betrekking hebben op de matrix van een weergaveobject, de kleurtransformatie en de pixelbeperkingen. De specifieke eigenschappen matrix, colorTransform en drie alleen-lezen-eigenschappen (concatenatedMatrix, concatenatedColorTransform en pixelBounds) worden in de vermelding voor de klasse Transform beschreven.

Elke eigenschap van het transformatieobject is zelf een object. Dit concept is van belang, omdat nieuwe waarden voor de matrix of objecten colorTransform alleen kunnen worden ingesteld door een nieuw object te maken en dit naar de eigenschap transform.matrix of transform.colorTransform te kopiëren.

Wanneer u bijvoorbeeld de waarde tx van de matrix van een weergaveobject wilt verhogen, moet u een kopie van het gehele matrixobject maken en vervolgens het nieuwe object in de matrixeigenschap van het object Transform kopiëren:

    var myMatrix:Matrix = myDisplayObject.transform.matrix;  
    myMatrix.tx += 10; 
    myDisplayObject.transform.matrix = myMatrix;  
    

U kunt de eigenschap tx niet rechtstreeks instellen. De volgende code heeft geen effect op myDisplayObject:

    myDisplayObject.transform.matrix.tx += 10;
    

U kunt ook een geheel transformatieobject kopiëren en dit aan de eigenschap transform van een ander weergaveobject toewijzen. Met de volgende code wordt het gehele transformatieobject van myOldDisplayObj naar myNewDisplayObj gekopieerd:

Het resulterende weergaveobject, myNewDisplayObj, heeft nu dezelfde waarden voor matrix, kleurtransformatie en pixelgrenzen als het oude weergaveobject, myOldDisplayObj.

Opmerking: AIR for TV-apparaten maken voor kleurtransformaties gebruik van hardwareversnelling, indien beschikbaar.

Verwante API-elementen

import flash.display.Sprite;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Transform;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.lineStyle(20, 0xFF2200);
square.graphics.beginFill(0x0000DD);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

var resultColorTransform:ColorTransform = new ColorTransform();
resultColorTransform.alphaMultiplier = 0.5;
resultColorTransform.redOffset = 155;
resultColorTransform.greenMultiplier = 0.5;

var skewMatrix:Matrix = new Matrix(1, 1, 0, 1);

square.addEventListener(MouseEvent.CLICK, transformer);

function transformer(event:MouseEvent):void {
    var transformation:Transform = square.transform;
    var tempMatrix:Matrix = square.transform.matrix;
    tempMatrix.concat(skewMatrix);
    square.transform.colorTransform = resultColorTransform;
    
    square.transform.matrix = tempMatrix;
}

Bepaalt of het weergaveobject zichtbaar is. Weergaveobjecten die niet zichtbaar zijn, worden uitgeschakeld. Wanneer voor een instantie InteractiveObject bijvoorbeeld visible=false geldt, kan er niet op worden geklikt.

import flash.text.TextField;
import flash.utils.Timer;
import flash.events.TimerEvent;

var tf:TextField = new TextField();
tf.text = "Hello.";
addChild(tf);

var tim:Timer = new Timer(250);
tim.start();
tim.addEventListener(TimerEvent.TIMER, blinker);

function blinker(event:TimerEvent):void {
    tf.visible = !tf.visible;
}

Geeft de breedte van het weergaveobject aan, in pixels. De breedte wordt berekend op basis van de grenzen van de inhoud van het weergaveobject. Wanneer u de eigenschap width instelt, wordt de eigenschap scaleX overeenkomstig aangepast, zoals in de volgende code wordt getoond:

    var rect:Shape = new Shape();
    rect.graphics.beginFill(0xFF0000);
    rect.graphics.drawRect(0, 0, 100, 100);
    trace(rect.scaleX) // 1;
    rect.width = 200;
    trace(rect.scaleX) // 2;

Met uitzondering van de objecten TextField en Video, heeft een weergaveobject zonder inhoud (zoals een lege sprite) een breedte van 0, ook wanneer u probeert width op een andere waarde in te stellen.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, widen);

function widen(event:MouseEvent):void {
    square.width += 10;
}

Hiermee wordt de x-coördinaat van de instantie DisplayObject ten opzichte van de lokale coördinaten van de bovenliggende DisplayObjectContainer bepaald. Wanneer het object in een DisplayObjectContainer met transformaties staat, bevindt het object zich in het lokale coördinatensysteem van de omsluitende DisplayObjectContainer. Wanneer een DisplayObjectContainer 90 graden tegen de klok in is geroteerd, nemen de onderliggende items van de DisplayObjectContainer dus een coördinatensysteem over dat 90 graden tegen de klok in is geroteerd. De coördinaten van het object verwijzen naar de positie van het registratiepunt.

import flash.display.Sprite;
import flash.utils.Timer;
import flash.events.TimerEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFF0000);
circle.graphics.drawCircle(100, 100, 100);
addChild(circle);

var tim:Timer = new Timer(50);
tim.start();
tim.addEventListener(TimerEvent.TIMER, bounce);

var xInc:Number = 2;

function bounce(event:TimerEvent):void {
    circle.x += xInc;
    if (circle.x > circle.width) {
        xInc = -2;
    }
    if (circle.x < 0) {
        xInc = 2;
    }
}

Hiermee wordt de y-coördinaat van de instantie DisplayObject ten opzichte van de lokale coördinaten van de bovenliggende DisplayObjectContainer bepaald. Wanneer het object in een DisplayObjectContainer met transformaties staat, bevindt het object zich in het lokale coördinatensysteem van de omsluitende DisplayObjectContainer. Wanneer een DisplayObjectContainer 90 graden tegen de klok in is geroteerd, nemen de onderliggende items van de DisplayObjectContainer dus een coördinatensysteem over dat 90 graden tegen de klok in is geroteerd. De coördinaten van het object verwijzen naar de positie van het registratiepunt.

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.wordWrap = true;
tf1.width = 40;
tf1.height = tf1.textHeight + 5;
addChild(tf1);

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.wordWrap = true;
tf2.width = 40;
tf2.height = tf2.textHeight + 5;
tf2.y = tf1.y + tf1.height + 5;
addChild(tf2);

Geeft de z-coördinaatpositie langs de z-as van de DisplayObject-instantie aan ten opzichte van de bovenliggende 3D-container. De eigenschap z wordt gebruikt voor 3D-coördinaten, niet voor scherm- of pixelcoördinaten.

Als u de eigenschap z voor een weergaveobject instelt op een andere waarde dan de standaardwaarde 0, wordt automatisch een bijbehorend Matrix3D-object gemaakt voor het aanpassen van de positie en stand van een weergaveobject in drie dimensies. Wanneer met de z-as wordt gewerkt, verandert het bestaande gedrag van de eigenschappen x en y van scherm- of pixelcoördinaten in posities ten opzichte van de 3D parent-container.

Een onderliggend element van de _root op positie x = 100, y = 100, z = 200 wordt bijvoorbeeld niet getekend op pixellocatie (100,100). Het onderliggende element wordt getekend waar deze wordt geplaatst door de berekening van de 3D-projectie. De berekening is:

(x*cameraFocalLength/cameraRelativeZPosition, y*cameraFocalLength/cameraRelativeZPosition)

Verwante API-elementen

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.display.Graphics;
    import flash.events.Event;
    import flash.geom.*;

    public class ZAxisExample1 extends MovieClip {
        private var ellipse1Back:int = 1;
        private var ellipse2Back:int = 1;
        private var depth:int = 1000;
        
        public function ZAxisExample1():void {
            
            var ellipse1 = drawEllipse((this.stage.stageWidth / 2) - 100, 
                                      (this.stage.stageHeight / 2), 100, 80, 10);
            var ellipse2 = drawEllipse((this.stage.stageWidth / 2) + 100, 
                                      (this.stage.stageHeight / 2), 100, 80, 300);

            this.addChild(ellipse1);
            this.addChild(ellipse2);
            
            ellipse1.addEventListener(Event.ENTER_FRAME, ellipse1FrameHandler);
            ellipse2.addEventListener(Event.ENTER_FRAME, ellipse2FrameHandler);
        }

        private function drawEllipse(x:Number, y:Number, w:Number, h:Number, z:Number):Shape {
            var s:Shape = new Shape();                            
            s.z = z;
            s.graphics.beginFill(0xFF0000);
            s.graphics.lineStyle(2);
            s.graphics.drawEllipse(x, y, w, h);
            s.graphics.endFill();
            return s;
        }

        private function ellipse1FrameHandler(e:Event):void {
            ellipse1Back = setDepth(e, ellipse1Back);
            e.currentTarget.z += ellipse1Back * 10;
        }

        private function ellipse2FrameHandler(e:Event):void {
            ellipse2Back = setDepth(e, ellipse2Back);
            e.currentTarget.z += ellipse2Back * 20;
        }

        private function setDepth(e:Event, d:int):int {
            if(e.currentTarget.z > depth) {
                e.currentTarget.z = depth; 
                d = -1;
            }else if (e.currentTarget.z <  0) {
                e.currentTarget.z = 0;
                d = 1;
            }
            return d;
        }
    }
}

Retourneert een rechthoek die het gebied van het weergaveobject aangeeft ten opzichte van het coördinatensysteem van het object targetCoordinateSpace. Bekijk de volgende code, die laat zien hoe de geretourneerde rechthoek kan variëren afhankelijk van de parameter targetCoordinateSpace die u aan de methode doorgeeft:

     var container:Sprite = new Sprite();
     container.x = 100;
     container.y = 100;
     this.addChild(container);
     var contents:Shape = new Shape();
     contents.graphics.drawCircle(0,0,100);
     container.addChild(contents);
     trace(contents.getBounds(container));
      // (x=-100, y=-100, w=200, h=200)
     trace(contents.getBounds(this));
      // (x=0, y=0, w=200, h=200)
     

Opmerking: gebruik de methoden localToGlobal() en globalToLocal() om de lokale coördinaten van het weergaveobject in weergavecoördinaten om te zetten of om de coördinaten in lokale coördinaten om te zetten.

De methode getBounds() is vergelijkbaar met de methode getRect(); de rechthoek die door de methode getBounds() wordt geretourneerd, bevat echter alle streken op vormen, terwijl dit niet geldt voor de rechthoek die door de methode getRect() wordt geretourneerd. Zie de beschrijving van de methode getRect() voor een voorbeeld.

Parameters

Verwante API-elementen

Retourneert een rechthoek die de grens van het weergaveobject aangeeft op basis van het coördinatensysteem dat wordt gedefinieerd door de paramater targetCoordinateSpace, minus enige streken op vormen. De waarden die door de methode getRect() worden geretourneerd, zijn gelijk aan of kleiner dan de waarden die door de methode getBounds() worden geretourneerd.

Opmerking: gebruik de methoden localToGlobal() en globalToLocal() om de lokale coördinaten van het weergaveobject in werkgebiedcoördinaten om te zetten of om de werkgebiedcoördinaten in lokale coördinaten om te zetten.

Parameters

Verwante API-elementen

import flash.display.CapsStyle;
import flash.display.JointStyle;
import flash.display.LineScaleMode;
import flash.display.Sprite;
import flash.geom.Rectangle;

var triangle:Sprite = new Sprite();
var color:uint = 0xFF0044;
var width:Number = 20;
var alpha:Number = 1.0;
var pixelHinting:Boolean = true;
var scaleMode:String = LineScaleMode.NORMAL;
var caps:String = CapsStyle.SQUARE;
var joints:String = JointStyle.MITER;
triangle.graphics.lineStyle(width, color, alpha, pixelHinting, scaleMode, caps, joints);

var triangleSide:Number = 100;
triangle.graphics.moveTo(0, 0);
triangle.graphics.lineTo(0, triangleSide);
triangle.graphics.lineTo(triangleSide, triangleSide);
triangle.graphics.lineTo(0, 0);

addChild(triangle);

trace(triangle.getBounds(this)); // (x=-10, y=-24.1, w=134.10000000000002, h=134.1)
trace(triangle.getRect(this));     // (x=0, y=0, w=100, h=100)

Hiermee worden de (algemene) werkgebiedcoördinaten van het object point omgezet in (lokale) objectcoördinaten.

Maak eerst een instantie van de klasse Point om deze methode te gebruiken. De x- en y-waarden die u toewijst, duiden algemene coördinaten aan omdat ze relatief zijn ten opzichte van de oorsprong (0,0) van het hoofdweergavegebied. Geef vervolgens de instantie Point als parameter door aan de methode globalToLocal(). De methode retourneert een nieuw object Point met x- en y-waarden die relatief zijn ten opzichte van de oorsprong van het weergaveobject in plaats van de oorsprong van het werkgebied.

Parameters

Verwante API-elementen

import flash.display.Shape;
import flash.geom.Point;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.x = 10;
addChild(circle);

var point1:Point = new Point(0, 0);
trace(circle.hitTestPoint(point1.x, point1.y, true)); // false
trace(circle.hitTestPoint(point1.x, point1.y, false)); // false
trace(circle.globalToLocal(point1)); // [x=-10, y=0]

var point2:Point = new Point(10, 1);
trace(circle.hitTestPoint(point2.x, point2.y, true)); // false
trace(circle.hitTestPoint(point2.x, point2.y, false)); // true
trace(circle.globalToLocal(point2)); // [x=0, y=1]

var point3:Point = new Point(30, 20);
trace(circle.hitTestPoint(point3.x, point3.y, true)); // true
trace(circle.hitTestPoint(point3.x, point3.y, false)); // true
trace(circle.globalToLocal(point3)); // [x=20, y=20]

Converteert een tweedimensionaal punt van de (algemene) werkruimtecoördinaten naar (lokale) coördinaten van een driedimensionaal weergaveobject.

Maak eerst een instantie van de klasse Point om deze methode te gebruiken. De x- en y-waarden die u toewijst aan het Point-object, duiden algemene coördinaten aan omdat ze relatief zijn ten opzichte van de oorsprong (0,0) van het hoofdweergavegebied. Vervolgens geeft u het Point-object door aan de methode globalToLocal3D() als de parameter point. De methode retourneert driedimensionale coördinaten als Vector3D-object met x-, y- en z-waarden die relatief zijn ten opzichte van de oorsprong van het driedimensionale weergaveobject.

Parameters

Evalueert het selectiekader van het weergaveobject om te zien of dit het selectiekader van het weergaveobject obj overlapt of snijdt.

Parameters

import flash.display.Shape;

var circle1:Shape = new Shape();
circle1.graphics.beginFill(0x0000FF);
circle1.graphics.drawCircle(40, 40, 40);
addChild(circle1);

var circle2:Shape = new Shape();
circle2.graphics.beginFill(0x00FF00);
circle2.graphics.drawCircle(40, 40, 40);
circle2.x = 50;
addChild(circle2);

var circle3:Shape = new Shape();
circle3.graphics.beginFill(0xFF0000);
circle3.graphics.drawCircle(40, 40, 40);
circle3.x = 100;
circle3.y = 67;
addChild(circle3);

trace(circle1.hitTestObject(circle2)); // true
trace(circle1.hitTestObject(circle3)); // false
trace(circle2.hitTestObject(circle3)); // true

Hiermee wordt het weergaveobject geëvalueerd om te zien of deze een punt dat is opgegeven door de parameters x en y, overlapt of doorsnijdt. De parameters x en y geven een punt op in de coördinaatruimte van het werkgebied, niet de weergaveobjectcontainer die het weergaveobject bevat (tenzij de weergaveobjectcontainer het werkgebied is).

Parameters

Verwante API-elementen

import flash.display.Shape;
import flash.geom.Point;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.x = 10;
addChild(circle);

var point1:Point = new Point(0, 0);
trace(circle.hitTestPoint(point1.x, point1.y, true)); // false
trace(circle.hitTestPoint(point1.x, point1.y, false)); // false
trace(circle.globalToLocal(point1)); // [x=-10, y=0]

var point2:Point = new Point(10, 1);
trace(circle.hitTestPoint(point2.x, point2.y, true)); // false
trace(circle.hitTestPoint(point2.x, point2.y, false)); // true
trace(circle.globalToLocal(point2)); // [x=0, y=1]

var point3:Point = new Point(30, 20);
trace(circle.hitTestPoint(point3.x, point3.y, true)); // true
trace(circle.hitTestPoint(point3.x, point3.y, false)); // true
trace(circle.globalToLocal(point3)); // [x=20, y=20]

Converteert een driedimensionaal punt van de (lokale) coördinaten van het driedimensionale weergaveobject naar een tweedimensionaal punt in de (algemene) werkruimtecoördinaten.

U kunt bijvoorbeeld alleen tweedimensionale coördinaten (x,y) gebruiken om te tekenen met de methode display.Graphics. Als u een driedimensionaal object wilt tekenen, moet u de driedimensionale coördinaten van een weergaveobject toewijzen aan tweedimensionale coördinaten. Eerst maakt u een instantie van de klasse Vector3D met de x-, y- en z-coördinaten van een driedimensionaal weergaveobject. Vervolgens geeft u het Vector3D-object door aan de methode local3DToGlobal() als de parameter point3d. De methode retourneert een tweedimensionaal Point-object dat u kunt gebruiken in de Graphics API om het driedimensionale object te tekenen.

Parameters

package {
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.display.Graphics;
    import flash.geom.*;

    public class Local3DToGlobalExample extends MovieClip {
        private var myCube:Sprite = new Sprite();
        private var v8:Vector.<Vector3D> = new Vector.<Vector3D>(8);

        public function Local3DToGlobalExample():void {
            this.x = -(this.stage.stageWidth / 2);
            this.y = -(this.stage.stageWidth / 2);

            v8[0] = new Vector3D(-40,-40,-40);
            v8[1] = new Vector3D(40,-40,-40);
            v8[2] = new Vector3D(40,-40,40);
            v8[3] = new Vector3D(-40,-40,40);
            v8[4] = new Vector3D(-40,100,-40);
            v8[5] = new Vector3D(40,100,-40);
            v8[6] = new Vector3D(40,100,40);
            v8[7] = new Vector3D(-40,100,40);

            myCube.x = (this.stage.stageWidth / 2);
            myCube.y = (this.stage.stageWidth / 2);
            myCube.z = 1;
            addChild(myCube);

            Cube();         
        }

        private function Cube():void {
            var ps:Point = new Point(0,0);

            myCube.graphics.lineStyle(2,0xFF0000);

            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[1]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[2]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[3]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.lineTo(ps.x, ps.y);

            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[5]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[6]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[7]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.lineTo(ps.x, ps.y);

            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[1]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[5]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[2]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[6]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[3]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[7]);
            myCube.graphics.lineTo(ps.x, ps.y);
        }
    }
}

Hiermee worden de (lokale) weergaveobjectcoördinaten van het object point omgezet in (algemene) werkgebiedcoördinaten.

Met deze methode kunt u alle gegeven x- en y-coördinaten omzetten van waarden ten opzichte van de linkerbovenhoek van een specifiek weergaveobject in waarden ten opzichte van de oorsprong (0,0) van het werkgebied (algemene coördinaten).

Maak eerst een instantie van de klasse Point om deze methode te gebruiken. De x- en y-waarden die u toewijst, duiden algemene coördinaten aan omdat ze relatief zijn ten opzichte van de oorsprong van het weergaveobject.

Geef vervolgens de instantie Point die u hebt gemaakt als parameter door aan de methode localToGlobal(). De methode retourneert een nieuw object Point met x- en y-waarden die relatief zijn ten opzichte van de oorsprong van het werkgebied in plaats van de oorsprong van het weergaveobject.

Parameters

Verwante API-elementen

import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.geom.Point;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
square.x = 100;
square.y = 200;

addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates)

function traceCoordinates(event:MouseEvent):void {
    var clickPoint:Point = new Point(square.mouseX, square.mouseY);
    trace("display object coordinates:", clickPoint);
    trace("stage coordinates:", square.localToGlobal(clickPoint));
}

Wordt verzonden wanneer een weergaveobject aan het weergaveoverzicht wordt toegevoegd. Deze gebeurtenis wordt door de volgende methoden geactiveerd: DisplayObjectContainer.addChild() en DisplayObjectContainer.addChildAt().

Deze gebeurtenis heeft de volgende eigenschappen:

Verwante API-elementen

Wordt verzonden wanneer een weergaveobject direct of via toevoeging van een subboomstructuur die het weergaveobject bevat, aan het weergaveoverzicht van het werkgebied wordt toegevoegd. Deze gebeurtenis wordt door de volgende methoden geactiveerd: DisplayObjectContainer.addChild() en DisplayObjectContainer.addChildAt().

Deze gebeurtenis heeft de volgende eigenschappen:

Verwante API-elementen

[uitzendgebeurtenis] Wordt verzonden wanneer de afspeelkop een nieuw frame ingaat. Als de afspeelkop niet beweegt, of als er slechts één frame is, wordt deze gebeurtenis continu verzonden in combinatie met de framesnelheid. Deze gebeurtenis is een uitzendgebeurtenis, wat betekent dat deze wordt verzonden door alle weergaveobjecten met een listener die is ingesteld voor deze gebeurtenis.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis heeft de volgende eigenschappen:

[uitzendgebeurtenis] Wordt verzonden wanneer de afspeelkop het huidige frame verlaat. Alle framescripts zijn uitgevoerd. Als de afspeelkop niet beweegt, of als er slechts één frame is, wordt deze gebeurtenis continu verzonden in combinatie met de framesnelheid. Deze gebeurtenis is een uitzendgebeurtenis, wat betekent dat deze wordt verzonden door alle weergaveobjecten met een listener die is ingesteld voor deze gebeurtenis.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis heeft de volgende eigenschappen:

[uitzendgebeurtenis] Wordt verzonden nadat de constructors van frameweergaveobjecten zijn uitgevoerd, maar voordat framescripts zijn uitgevoerd. Als de afspeelkop niet beweegt, of als er slechts één frame is, wordt deze gebeurtenis continu verzonden in combinatie met de framesnelheid. Deze gebeurtenis is een uitzendgebeurtenis, wat betekent dat deze wordt verzonden door alle weergaveobjecten met een listener die is ingesteld voor deze gebeurtenis.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden vlak voordat een weergaveobject uit het weergaveoverzicht wordt verwijderd. Twee methoden van de klasse DisplayObjectContainer genereren deze gebeurtenis: removeChild() en removeChildAt().

De volgende methoden van een object DisplayObjectContainer genereren deze gebeurtenis ook als een object moet worden verwijderd om ruimte te maken voor het nieuwe object: addChild(), addChildAt() en setChildIndex().

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden vlak voordat een weergaveobject uit het weergaveoverzicht wordt verwijderd. Dit kan rechtstreeks gebeuren of door de subboomstructuur te verwijderen die het weergaveobject bevat. Twee methoden van de klasse DisplayObjectContainer genereren deze gebeurtenis: removeChild() en removeChildAt().

De volgende methoden van een object DisplayObjectContainer genereren deze gebeurtenis ook als een object moet worden verwijderd om ruimte te maken voor het nieuwe object: addChild(), addChildAt() en setChildIndex().

Deze gebeurtenis heeft de volgende eigenschappen:

[uitzendgebeurtenis] Wordt verzonden wanneer de weergavelijst op het punt staat te worden bijgewerkt en gerenderd. Deze gebeurtenis biedt de laatste mogelijkheid voor objecten die naar deze gebeurtenis luisteren om wijzigingen aan te brengen voordat het weergaveoverzicht wordt gerenderd. U moet de methode invalidate() van het object Stage aanroepen, telkens wanneer u een gebeurtenis render wilt verzenden. Render-gebeurtenissen worden alleen naar een object verzonden bij wederzijds vertrouwen tussen dat object en het object dat Stage.invalidate() heeft aangeroepen. Deze gebeurtenis is een uitzendgebeurtenis, wat betekent dat deze wordt verzonden door alle weergaveobjecten met een listener die is ingesteld voor deze gebeurtenis.

Opmerking: deze gebeurtenis wordt niet verzonden wanneer het beeld niet wordt gerenderd. Dit is het geval wanneer de inhoud is geminimaliseerd of verborgen.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis heeft de volgende eigenschappen:

1. Klasse-eigenschappen worden gedeclareerd voor de kleur en de grootte van het vierkant.
2. De constructor roept de methode draw() aan. Deze tekent in het werkgebied een oranje vierkant op de standaardcoördinaten x = 0, y = 0.
3. De volgende gebeurtenislistenermethoden zijn gekoppeld aan het vierkant:
   • addedHandler() luistert naar gebeurtenissen added, die worden verzonden wanneer het vierkant aan het weergaveoverzicht wordt toegevoegd.
   • enterFrameHandler() luistert naar gebeurtenissen enterFrame, die in dit voorbeeld geen echte betekenis hebben.
   • removedHandler() luistert naar gebeurtenissen removed, die worden verzonden wanneer het vierkant uit het weergaveoverzicht wordt verwijderd. Dit gebeurt wanneer op het vierkant wordt geklikt.
   • clickHandler() luistert naar gebeurtenissen click, die worden verzonden wanneer op het oranje vierkant wordt geklikt.
   • renderHandler() luistert naar gebeurtenissen render nadat het weergaveoverzicht is bijgewerkt.

package {
    import flash.display.Sprite;

    public class DisplayObjectExample extends Sprite {
        public function DisplayObjectExample() {
            var child:CustomDisplayObject = new CustomDisplayObject();
            addChild(child);
        }
    }
}

import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.Stage;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.events.*;

class CustomDisplayObject extends Sprite {
    private var bgColor:uint = 0xFFCC00;
    private var size:uint    = 80;

    public function CustomDisplayObject() {
        draw();
        addEventListener(Event.ADDED, addedHandler);
        addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        addEventListener(Event.REMOVED, removedHandler);
        addEventListener(MouseEvent.CLICK, clickHandler);
        addEventListener(Event.RENDER, renderHandler);
    }

    private function draw():void {
        graphics.beginFill(bgColor);
        graphics.drawRect(0, 0, size, size);
        graphics.endFill();
    }

    private function clickHandler(event:MouseEvent):void {
        trace("clickHandler: " + event);
        parent.removeChild(this);
    }

    private function addedHandler(event:Event):void {
        trace("addedHandler: " + event);
        stage.scaleMode = StageScaleMode.NO_SCALE;
        stage.align = StageAlign.TOP_LEFT;
        stage.addEventListener("resize", resizeHandler);
    }

    private function enterFrameHandler(event:Event):void {
        trace("enterFrameHandler: " + event);
        removeEventListener("enterFrame", enterFrameHandler);
    }

    private function removedHandler(event:Event):void {
        trace("removedHandler: " + event);
        stage.removeEventListener("resize", resizeHandler);
    }

    private function renderHandler(event:Event):void {
        trace("renderHandler: " + event);
    }

    private function resizeHandler(event:Event):void {
        trace("resizeHandler: " + event);
    }
}