spark.effectsAnimateTransform3D L’effet AnimateTransform3D étend les possibilités de l’effet AnimateTransform pour les propriétés de transformation 3D. The <s:AnimateTransform> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AnimateTransform
    Properties
    id="ID"
    applyChangesPostLayout="true"
    applyLocalProjection="false"
    autoCenterProjection="true"
    fieldOfView="no default"
    focalLength="no default"
    projectionX="0"
    projectionY="0"
    removeLocalProjectionWhenComplete="false"
  />
]]>spark.effects:AnimateTransform L’effet AnimateTransform3D étend les possibilités de l’effet AnimateTransform pour les propriétés de transformation 3D. Comme l’effet AnimateTransform, cet effet n’est pas destiné à être utilisé directement, mais fournit des fonctionnalités communes qui est utilisé par ses sous-classes. Pour obtenir des effets 3D, utilisez les sous-classes Move3D, Rotate3D, et Scale3D.

Comme avec l’effet AnimateTransform, il existe certaines propriétés de cet effet qui sont partagés avec tous les autres effets de transformation qui sont combinées avec l’exécution. En particulier, les propriétés liées à la projection applyLocalProjection, removeProjectionWhenComplete, autoCenterProjection, fieldOfView, focalLength, projectionX et projectionY sont toutes des propriétés partagées. Définissez ces propriétés de même sur tous les effets 3D qui sont combinés dans un effet composite pour obtenir des résultats prévisibles.

spark.effects.supportClasses.AnimateTransformInstanceAnimateTransform3D Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. autoCenterProjection Défini sur false pour désactiver un effet 3D qui définirait automatiquement le point de projection au centre de la cible. truetrue Défini sur false pour désactiver un effet 3D qui définirait automatiquement le point de projection au centre de la cible. Vous utilisez ensuite les propriétés projectionX et projectionY pour définir explicitement le point de projection point comme décalage du point de projection de la coordonnée (0, 0) de la cible.

Les effets 3D fonctionnant par la mise en correspondance d’une image en trois dimensions sur une représentation en deux dimensions pour un affichage sur un écran d’ordinateur. Le point de projection définit le centre du champ d’affichage et contrôle la façon dont la cible est projetée de trois dimensions sur l’écran.

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionfieldOfView Spécifie l’angle, en degrés compris entre 0 et 180, du champ de vision en trois dimensions. Spécifie l’angle, en degrés compris entre 0 et 180, du champ de vision en trois dimensions. Cette valeur détermine la puissance de la transformation de perspective, et la distorsion s’applique à un objet d’affichage tridimensionnel avec coordonnée z non nulle.

Une valeur proche de 0 signifie que les coordonnées bidimensionnelles x et y de l’écran sont quasiment les mêmes que les coordonnées tridimensionnelles x, y et z, avec très peu ou aucune distorsion. En d’autres termes, dans le cas d’un angle faible, un objet d’affichage se déplaçant vers le bas de l’axe z semble conserver à peu près la même taille et ne se déplacer que très peu.

Une valeur proche de 180 degrés entraînent un effet de déformation : les positions dont la valeur z est inférieure à 0 sont exagérées, tandis que les positions dont la valeur z est supérieure à 0 sont réduites. Avec un très grand angle, un objet d’affichage se déplaçant le long de l’axe z semble changer de taille rapidement et se déplacer sur de grandes distances. Si le champ de vision est défini sur 0 ou 180, rien n’est visible à l’écran.

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionflash.geom.PerspectiveProjectionfocalLength Distance entre l’oeil ou l’origine du point de vue (0,0,0) et l’objet d’affichage placé sur l’axe z. Distance entre l’oeil ou l’origine du point de vue (0,0,0) et l’objet d’affichage placé sur l’axe z. Pendant la transformation de la perspective, la propriété focalLength est calculée dynamiquement à l’aide de l’angle du champ de vision et des proportions de la scène (largeur de la scène divisée par sa hauteur).

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionflash.geom.PerspectiveProjectionprojectionX Définit le point de projection comme le décalage du point de projection dans la direction x à partir de la coordonnée (0, 0) de la cible. 0 Définit le point de projection comme le décalage du point de projection dans la direction x à partir de la coordonnée (0, 0) de la cible. Par défaut, lorsque vous appliquez un effet 3D, l’effet définit automatiquement le point de projection au centre de la cible. Vous pouvez définir la propriété autoCenterProjection de l’effet sur false pour désactiver ce paramètre par défaut et utilisez les propriétés projectionX et projectionY.

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionprojectionY Définit le point de projection comme le décalage du point de projection dans la direction y à partir de la coordonnée (0, 0) de la cible.0 Définit le point de projection comme le décalage du point de projection dans la direction y à partir de la coordonnée (0, 0) de la cible. Par défaut, lorsque vous appliquez un effet 3D, l’effet définit automatiquement le point de projection au centre de la cible. Vous pouvez définir la propriété autoCenterProjection de l’effet sur false pour désactiver ce paramètre par défaut et utilisez les propriétés projectionX et projectionY.

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionremoveLocalProjectionWhenComplete Si la valeur est true, l’effet supprime la projection de perspective depuis le parent du composant cible lorsque la lecture se termine. falsefalse Si la valeur est true, l’effet supprime la projection de perspective depuis le parent du composant cible lorsque la lecture se termine. Par défaut, la projection de perspective est conservée.

Cette propriété est uniquement utilisée lorsque la projection applyLocalProjection est définie sur true.

applyLocalProjectionapplyChangesPostLayout Utilisé par les sous-classes de l’effet AnimateTransform afin de spécifier si l’effet modifie les valeurs de transformation utilisées par le gestionnaire de mise en page ou si elle change les valeurs utilisées après l’exécution de la mise en page. true Utilisé par les sous-classes de l’effet AnimateTransform afin de spécifier si l’effet modifie les valeurs de transformation utilisées par le gestionnaire de mise en page ou si elle change les valeurs utilisées après l’exécution de la mise en page. Etant donné que le système de mise en forme Flex ignore les propriétés de transformation 3D, cette classe remplace la propriété AnimateTransform.applyChangesPostLayout afin de définir la valeur par défaut sur true pour les effets 3D. applyLocalProjection Si la valeur est true, l’effet crée une projection de perspective à l’aide des autres propriétés de projection de l’effet et l’applique au parent du composant cible au début de la lecture. true Si la valeur est true, l’effet crée une projection de perspective à l’aide des autres propriétés de projection de l’effet et l’applique au parent du composant cible au début de la lecture. Par défaut, la projection reste appliquée au parent à la fin de l’effet. Pour la supprimer à ce moment-là, définissez removeLocalProjectionWhenComplete sur true. removeLocalProjectionWhenCompleteAnimateTransitionShader L’effet AnimateShaderTransition anime une transition entre deux images bitmap, l’une d’entre elles représentant l’état de début (bitmapFrom), l’autre l’état de fin (bitmapTo). L’effet AnimateShaderTransition utilise Pixel Bender, qui n’est pas pris en charge par les applications mobile AIR. The <s:AnimateTransitionShader> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AnimateTransitionShader
    Properties
    id="ID"
    bitmapFrom="no default"
    bitmapTo="no default"
    shaderByteCode="no default"
    sahderProperties="no default"
  />
]]>spark.effects:Animate L’effet AnimateShaderTransition anime une transition entre deux images bitmap, l’une d’entre elles représentant l’état de début (bitmapFrom), l’autre l’état de fin (bitmapTo).

L’animation est réalisée en exécutant un programme pixel shader, spécifié par la propriété shader, et en utilisant comme entrée les deux images bitmap. Les images bitmap sont représentées par une occurrence de la classe flash.display.BitmapData. Vous pouvez créer votre propre programme pixel shader à l’aide d’Adobe Pixel Bender Toolkit.

Si l’une des deux images bitmap n’est pas fournie, cette valeur est déterminée de façon dynamique, soit à partir de l’état approprié de la cible dans le cas d’une transition, soit directement à partir de la cible si l’effet ne fait pas partie d’une transition. Si l’effet fait partie d’une transition et que l’objet cible disparaît ou apparaît pendant ce changement d’état, une image bitmap entièrement transparente est utilisée pour représenter l’objet manquant.

Cet effet peut uniquement être exécuté sur des cibles de type UIComponent ou GraphicElement, car l’acquisition de l’image bitmap de l’objet nécessite de disposer d’informations sur l’objet qui sont présentes uniquement dans ces classes.

Comme l’effet s’appuie sur des images bitmap et que le programme pixel shader sous-jacent suppose que la taille des deux images est identique, l’effet fonctionne correctement uniquement si les deux images bitmap sont de la même taille. Par conséquent, si l’objet cible change de taille ou d’orientation et que cela entraîne une modification de la taille du cadre de sélection, il se peut que l’effet ne soit pas lu correctement.

Cet effet et ses sous-classes diffèrent des autres effets de Flex, dans la mesure où ils sont destinés à fonctionner de façon autonome. Par conséquent, leur résultat est imprévisible s’ils sont exécutés parallèlement à d’autres effets. Cette contrainte est due au fait que les deux images bitmap avant/après sont collectées avant le début de l’effet. Ainsi, si l’objet cible subit une quelconque modification après le calcul de ces images bitmap, par exemple si un autre effet modifie les propriétés de la cible, ces modifications ne sont pas prises en compte dans l’image bitmap précalculée et les résultats sont alors imprévisibles. Pour assurer le bon déroulement de ces effets bitmap, ils doivent être lus de façon exclusive sur leurs objets cible.

flash.display.BitmapDataspark.effects.supportClasses.AnimateTransitionShaderInstancespark.primitives.supportClasses.GraphicElementAnimateTransitionShader Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. bitmapFrom Données bitmap représentant l’état de départ de cet effet. Données bitmap représentant l’état de départ de cet effet. Si cette propriété n’est pas définie, elle est calculée automatiquement lors de la lecture de l’effet, en prenant un instantané de l’objet cible ou en utilisant une image bitmap transparente si l’objet n’existe pas dans l’état d’affichage de départ d’une transition. bitmapTo Données bitmap représentant l’état de fin de cet effet. Données bitmap représentant l’état de fin de cet effet. Si cette propriété n’est pas définie, elle est calculée automatiquement lors de la lecture de l’effet, en prenant un instantané de l’objet cible ou en utilisant une image bitmap transparente si l’objet n’existe pas dans l’état d’affichage de fin d’une transition. shaderByteCode Pseudo-code binaire du programme pixel shader utilisé par l’effet pour réaliser l’animation entre les deux images bitmap. Pseudo-code binaire du programme de pixel shader utilisé par l’effet pour réaliser l’animation entre les deux images bitmap. Cette propriété peut être représentée par un objet ByteArray ou un objet Class représentant un objet ByteArray (cet objet Class est obtenu lorsque vous imbriquez une ressource).

Le programme pixel shader peut disposer de fonctions et d’entrées arbitraires, mais il doit au minimum posséder trois entrées image4. La première entrée, dont le nom n’a pas d’importance, n’est normalement pas utilisée par le code de votre programme pixel shader : elle sert uniquement à satisfaire la première exigence de Flash, qui nécessite d’affecter un objet filtré à la première entrée. Les entrées qui ne sont pas du tout utilisées dans un programme pixel shader peuvent être optimisées en sortie. Par conséquent, le code doit faire référence au moins une fois à cette entrée.

Au moins deux autres entrées d’images bitmap doivent être définies. Celles-ci doivent être appelées from et to et correspondre respectivement aux images avant et après. Enfin, vous devez définir un paramètre float appelé progress, qui doit contenir la fraction écoulée de l’effet.

Deux paramètres facultatifs peuvent être définis : width et height. Lorsqu’ils sont définis, ils prennent automatiquement les valeurs de largeur et de hauteur de la cible de l’effet.

Pour plus d’informations sur la création de programmes pixel shader pour Flash, voir la documentation de Pixel Bender Toolkit. Le code source du fichier CrossFade.pbk est disponible dans le répertoire frameworks\projects\flex4\src\spark\effects du code source de Flex.

shaderProperties Mappage de paires de paramètres nom/valeur transmis au programme pixel shader avant la lecture. Mappage de paires de paramètres nom/valeur transmis au programme pixel shader avant la lecture. Par exemple, pour définir un paramètre appelé direction dans un shader à l’aide d’un fichier Pixel Bender pbj dans Wipe.pbj, le code d’appel peut se présenter comme suit : 
       [Embed(source="Wipe.pbj", mimeType="application/octet-stream")]
       private var WipeCodeClass:Class;
       var shaderEffect = new AnimateTransitionShader();
       shaderEffect.shaderByteCode = WipeCodeClass;
       shaderEffect.shaderProperties = {direction : 1};
Move3D La classe Move3D déplace un objet cible dans le x, y et z dimensions. The <s:Move3D> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:Move3D
    Properties
    id="ID"
    xBy="no default"
    xFrom="no default"
    xTo="no default"
    yBy="no default"
    yFrom="no default"
    yTo="no default"
    zBy="no default"
    zFrom="no default"
    zTo="no default"
  />
]]>spark.effects:AnimateTransform3D La classe Move3D déplace un objet cible dans le x, y et z dimensions. Les spécifications de propriété x, y et z de l’effet Move3D indiquent le changement sur x, y et z qui doit se passer dans le centre de transformation autour duquel l’effet de transformation globale se produit.

Comme tous les effets de type AnimateTransform, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement, car il dépend des fonctions de transformation propres à ces classes. Par ailleurs, les effets de transformation s’exécutant en parallèle sur la même cible s’exécutent comme une seule occurrence d’effet. Par conséquent, les effets de transformation partagent le centre de transformation défini par l’un des effets contributeurs.

spark.effects.MoveMove3D Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. xBy Nombre de pixels de déplacement de la position x de la cible. Nombre de pixels de déplacement de la position x de la cible. Les valeurs peuvent être négatives. xFrom Position x initiale de la cible, en pixels. Position x initiale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. xTo Valeur x finale, en pixels. Valeur x finale, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. yBy Nombre de pixels de déplacement de la position y de la cible. Nombre de pixels de déplacement de la position y de la cible. Les valeurs peuvent être négatives. yFrom Position y initiale de la cible, en pixels. Position y initiale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. yTo Position y finale de la cible, en pixels. Position y finale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de fin si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. zBy Nombre de pixels de déplacement de la position z de la cible. Nombre de pixels de déplacement de la position z de la cible. Les valeurs peuvent être négatives. zFrom Position z initiale de la cible. Position z initiale de la cible. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. zTo Position z finale de la cible. Position z finale de la cible. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. Wipe L’effet Wipe réalise un effet de transition bitmap en opérant un balayage directionnel entre la première et la deuxième image bitmap. L’effet Wipe utilise Pixel Bender, qui n’est pas pris en charge par les applications mobile AIR. The <s:Wipe> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:Wipe
    Properties
    id="ID"
    direction="right"
  />
]]>spark.effects:AnimateTransitionShader L’effet Wipe réalise un effet de transition bitmap en opérant un balayage directionnel entre la première et la deuxième image bitmap. Ce balayage fait entrer la deuxième image bitmap pendant l’animation, dans le sens indiqué par la propriété direction.

Un programme pixel shader chargé par l’effet exécute l’effet de l’image bitmap sous-jacente. Si vous souhaitez utiliser une autre comportement Wipe, vous pouvez spécifier un programme pixel shader. Le programme pixel shader doit se conformer aux contraintes spécifiée pour la propriété shaderByteCode de la classe AnimateTransitionShader et indiquer trois paramètres supplémentaires. Les paramètres supplémentaires requis par le shader Wipe sont les suivants :

  • un paramètre int direction, dont la valeur a la même signification que la propriété String de la classe Wipe.
  • Deux paramètres à virgule flottante : imageWidth et imageHeight.

Tous ces paramètres sont définis sur le shader lorsque la lecture de l’effet commence. Par conséquent, les paramètres doivent exister et réaliser une action appropriée pour que l’effet puisse fonctionner correctement.

spark.effects.WipeDirectionspark.effects.AnimateTransitionShaderspark.effects.AnimateTransitionShader.shaderByteCodeWipe Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. direction Sens dans lequel le balayage est réalisé pendant l’animation : WipeDirection.RIGHT, WipeDirection.LEFT, WipeDirection.UP ou WipeDirection.DOWN.rightWipeDirection.RIGHT Sens dans lequel le balayage est réalisé pendant l’animation : WipeDirection.RIGHT, WipeDirection.LEFT, WipeDirection.UP ou WipeDirection.DOWN. WipeDirection.RIGHTWipeDirection.UPWipeDirection.LEFTWipeDirection.DOWNCallAction L’effet CallAction applique la fonction spécifiée par la propriété functionName à l’objet target, en utilisant des arguments facultatifs spécifiés par la propriété args. The <s:CallAction> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:CallAction
    Properties
    id="ID"
    functionName="no default"
    args="no default"
  />
]]>mx.effects:Effect L’effet CallAction applique la fonction spécifiée par la propriété functionName à l’objet target en utilisant des arguments facultatifs spécifiés par la propriété args. Cet effet est utile dans les séquences d’effet dans lesquelles un appel de fonction peut être inclus dans un effet composite. spark.effects.supportClasses.CallActionInstanceCallAction Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. args Arguments transmis à la fonction appelée par cet effet. Arguments transmis à la fonction appelée par cet effet. functionName Nom de la fonction appelée sur la cible lors de la lecture de cet effet. Nom de la fonction appelée sur la cible lors de la lecture de cet effet. AddAction La classe AddAction définit un effet d’action correspondant à la propriété AddChild d’une définition d’état d’affichage.The <s:AddAction> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AddAction
    Properties
    id="ID"
    index="-1"
    position="index"
    relativeTo=""
  />
]]>mx.effects:Effect La classe AddAction définit un effet d’action correspondant à la propriété AddChild d’une définition d’état d’affichage. L’effet AddAction peut notamment être utilisé dans une définition de transition pour définir à quel moment de la transition un changement d’état d’affichage défini par une propriété AddChild doit se produire. spark.effects.supportClasses.AddActionInstancemx.states.AddChildAddAction Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. AFTER Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo.after Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo. positionBEFORE Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo.before Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo. positionFIRST_CHILD Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo.firstChild Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo. positionINDEX Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo.index Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo. positionLAST_CHILD Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo.lastChild Constante permettant de spécifier la position à laquelle l’élément doit être ajouté, par rapport à l’objet spécifié par la propriété relativeTo. positionindex Index de l’enfant dans le parent.-1-1 Index de l’enfant dans le parent. La valeur -1 signifie que l’enfant doit être ajouté comme dernier enfant du parent. position Position de l’enfant dans la liste d’affichage, par rapport à l’objet spécifié par la propriété relativeTo.indexAddAction.INDEX Position de l’enfant dans la liste d’affichage, par rapport à l’objet spécifié par la propriété relativeTo. Les valeurs possibles sont les suivantes : AddAction.BEFORE, AddAction.AFTER, AddAction.FIRST_CHILD, AddAction.LAST_CHILD et AddAction.INDEX, où AddAction.INDEX indique que la propriété index doit être utilisée pour déterminer la position de l’enfant. BEFOREAFTERFIRST_CHILDLAST_CHILDINDEXrelativeTo Emplacement dans lequel le composant enfant est ajouté. Position à laquelle le composant enfant est ajouté. Par défaut, Flex détermine cette valeur à partir de la propriété AddChild de la définition d’état d’affichage. AnimateFilter L’effet AnimateFilter applique une occurrence mx.filters.IBitmapFilter à la cible et vous permet d’animer les propriétés du filtre entre les valeurs.The <s:AnimateFilter> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AnimateFilter
    Properties
    id="ID"
    bitmapFilter="no default"
  />
]]>spark.effects:Animate L’effet AnimateFilter applique une occurrence mx.filters.IBitmapFilter à la cible et vous permet d’animer les propriétés du filtre entre les valeurs. Contrairement aux effets qui animent les propriétés de la cible, l’effet AnimateFilter anime les propriétés du filtre appliqué à la cible.

Les filtres que vous pouvez utiliser avec cet effet sont définis dans le package spark.filters. DropShadowFilter, GlowFilter, BlurFilter, et ShaderFilter font partie des filtres couramment utilisés.

Pour définir les propriétés du filtre à animer, transmettez un tableau d’objets SimpleMotionPath à la propriété motionPath de l’effet AnimateFilter. Chaque objet SimpleMotionPath définit une propriété du filtre ainsi que les valeurs de départ et de fin de la propriété.

spark.effects.supportClasses.AnimateFilterInstanceAnimateFilter Constructeur.targetnullObjet à animer à l’aide de cet effet. filternullFiltre à appliquer à la cible. Les filtres que vous pouvez utiliser avec cet effet sont définis dans le package spark.filters. Constructeur. bitmapFilter Occurrence IBitmapFilter à appliquer et à animer. Occurrence IBitmapFilter à appliquer et à animer.

Les filtres que vous pouvez utiliser avec cet effet sont définis dans le package spark.filters. DropShadowFilter, GlowFilter, BlurFilter, et ShaderFilter font partie des filtres couramment utilisés.

Rotate L’effet Rotate fait pivoter un objet cible dans le plan x, y autour du centre de transformation.The <s:Rotate> tag inherits all of the tag attributes of its of its superclass, and adds the following tag attributes:

  <s:Rotate
    id="ID"
    angleBy="val"
    angleFrom="val"
    angleTo="val"
   />
]]>spark.effects:AnimateTransform L’effet Rotate fait pivoter un objet cible dans le plan x, y autour du centre de transformation.

Si vous spécifiez au moins deux des valeurs d’angle (angleFrom, angleTo ou angleBy), Flex calcule la troisième valeur. Si vous spécifiez les trois valeurs d’angle, Flex ignore la valeur angleBy.

Comme tous les effets de type AnimateTransform, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement, car il dépend des fonctions de transformation propres à ces classes.

Rotate Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. angleBy Degrés de rotation de l’objet cible. Degrés de rotation de l’objet cible. La valeur peut être négative.

Si la valeur de angleBy est négative, la cible pivote en sens anti-horaire. Dans le cas contraire, elle pivote en sens horaire. Pour faire tourner la cible plusieurs fois, définissez cette valeur sur un grand nombre positif ou sur un petit nombre négatif.

angleFrom Angle de départ de la rotation de l’objet cible, en degrés. Angle de départ de la rotation de l’objet cible, en degrés. Les valeurs possibles vont de 0 à 360. angleTo Angle de fin de la rotation de l’objet cible, en degrés. Angle de fin de la rotation de l’objet cible, en degrés. Les valeurs peuvent être soit positives, soit négatives.

Si la valeur de angleTo est inférieure à la valeur de angleFrom, la cible pivote en sens anti-horaire. Dans le cas contraire, elle pivote en sens horaire. Pour faire tourner la cible plusieurs fois, définissez cette valeur sur un grand nombre positif ou sur un petit nombre négatif.

Scale3D La classe Scale3D met à l’échelle un objet cible en trois dimensions autour d centre de transformation. The <s:Scale3D> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:Scale3D
    Properties
    id="ID"
    scaleXBy="no default"
    scaleXFrom="no default"
    scaleXTo="no default"
    scaleYBy="no default"
    scaleYFrom="no default"
    scaleYTo="no default"
    scaleZBy="no default"
    scaleZFrom="no default"
    scaleZTo="no default"
  />
]]>spark.effects:AnimateTransform3D La classe Scale3D met à l’échelle un objet cible en trois dimensions autour d centre de transformation. Une échelle de 2.0 signifie que l’objet est agrandi d’un facteur 2 et une échelle de 0.5 que l’objet est réduit d’un facteur 2. La valeur de mise à l’échelle 0.0 n’est pas valide.

Comme tous les effets de type AnimateTransform, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement, car il dépend des fonctions de transformation propres à ces classes. Par ailleurs, les effets de transformation s’exécutant en parallèle sur la même cible s’exécutent comme une seule occurrence d’effet. Par conséquent, les effets de transformation partagent le centre de transformation défini par l’un des effets contributeurs.

Scale3D Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. scaleXBy Facteur de mise à l’échelle à appliquer à l’objet dans la direction x. Facteur de mise à l’échelle à appliquer à l’objet dans la direction x. Il s’agit d’un paramètre facultatif pouvant être utilisé à la place de l’une des valeurs de départ et de fin, pour spécifier le delta à ajouter à la valeur de départ ou obtenir la valeur de départ en soustrayant cette valeur de la valeur de fin. scaleXFrom Facteur de mise à l’échelle de départ dans la direction x. Facteur de mise à l’échelle de départ dans la direction x. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleXTo Facteur de mise à l’échelle de fin dans la direction x. Facteur de mise à l’échelle de fin dans la direction x. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleYBy Facteur de mise à l’échelle à appliquer à l’objet dans la direction y. Facteur de mise à l’échelle à appliquer à l’objet dans la direction y. Il s’agit d’un paramètre facultatif pouvant être utilisé à la place de l’une des valeurs de départ et de fin, pour spécifier le delta à ajouter à la valeur de départ ou obtenir la valeur de départ en soustrayant cette valeur de la valeur de fin. scaleYFrom Facteur de mise à l’échelle de départ dans la direction y. Facteur de mise à l’échelle de départ dans la direction y. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleYTo Facteur de mise à l’échelle de fin dans la direction y. Facteur de mise à l’échelle de fin dans la direction y. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleZBy Facteur de mise à l’échelle à appliquer à l’objet dans la direction z. Facteur de mise à l’échelle à appliquer à l’objet dans la direction z. Il s’agit d’un paramètre facultatif pouvant être utilisé à la place de l’une des valeurs de départ et de fin, pour spécifier le delta à ajouter à la valeur de départ ou obtenir la valeur de départ en soustrayant cette valeur de la valeur de fin. scaleZFrom Facteur de mise à l’échelle de départ dans la direction z. Facteur de mise à l’échelle de départ dans la direction z. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleZTo Facteur de mise à l’échelle de fin dans la direction z. Facteur de mise à l’échelle de fin dans la direction z. La valeur de mise à l’échelle 0.0 n’est pas valide. Move L’effet Move déplace l’objet cible dans les directions x et y.The <s:Move> tag inherits all of the tag attributes of its of its superclass, and adds the following tag attributes:

  <s:Move
    id="ID"
    xBy="val"
    xFrom="val" 
    xTo="val"
    yBy="val"
    yFrom="val"
    yTo="val"
   />
]]>spark.effects:AnimateTransform L’effet Move déplace l’objet cible dans les directions x et y. Les spécifications de propriété x, y et z de l’effet Move indiquent le changement sur x, y et z qui doit se passer dans le centre de transformation autour duquel l’effet de transformation globale se produit. Ainsi, par exemple, si la propriété autoCenterTransform est définie, les valeurs from/to/by de cet effet définissent l’ampleur du déplacement du centre de la cible et non les coordonnées (x,y) de la cible.

Comme tous les effets de transformation, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement.

Move Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. xBy Nombre de pixels de déplacement de la position x de la cible. Nombre de pixels de déplacement de la position x de la cible. Les valeurs peuvent être négatives. xFrom Position x initiale de la cible, en pixels. Position x initiale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. xTo Valeur x finale, en pixels. Valeur x finale, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. yBy Nombre de pixels de déplacement de la position y de la cible. Nombre de pixels de déplacement de la position y de la cible. Les valeurs peuvent être négatives. yFrom Position y initiale de la cible, en pixels. Position y initiale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de départ si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. yTo Position y finale de la cible, en pixels. Position y finale de la cible, en pixels. Lorsque ce paramètre est omis, Flex utilise soit la valeur de l’état d’affichage de fin si l’effet fait partie d’une transition d’état, soit la valeur actuelle de la cible. CrossFade L’effet CrossFade réalise un effet de transition bitmap en opérant un effet crossfade entre la première et la deuxième image bitmap. L’effet CrossFade utilise Pixel Bender, qui n’est pas pris en charge par les applications mobile AIR. spark.effects:AnimateTransitionShader L’effet CrossFade réalise un effet de transition bitmap en opérant un effet crossfade entre la première et la deuxième image bitmap. Le fondu enchaîné mélange les deux images bitmap sur la durée de l’animation.

A chaque instant de l’animation, où la fraction écoulée et accélérée de l’animation est f et où les valeurs de pixel des première et deuxième images bitmap sont v1 et v2, la nouvelle valeur de pixel v d’un pixel de l’image est : 

v = v1 * (1 - f) + v2 * f

L’effet bitmap est exécuté par un programme pixel shader chargé par l’effet. Vous pouvez spécifier un autre comportement de fondu enchaîné en spécifiant un programme pixel shader pour la propriété shaderCode. Ce programme pixel shader doit respecter les exigences définies dans l’effet AnimateShaderTransition.

spark.effects.AnimateTransitionShaderspark.effects.AnimateTransitionShader.shaderByteCodeCrossFade Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. Fade L’effet Fade anime la propriété alpha d’un composant.The <s:Fade> tag inherits the tag attributes of its superclass, and adds the following tag attributes:

  <s:Fade 
    id="ID"
    alphaFrom="val"
    alphaTo="val"
  />
]]>spark.effects:Animate L’effet Fade anime la propriété alpha d’un composant. Si lue manuellement (hors d’une transition) sur un objet dont la propriété visibleest définie sur false, et pour animeralpha entre zéro et une valeur non nulle, il sera défini visible sur true comme un effet secondaire de fondu. Si elle est exécutée comme une partie intégrante d’une transition, elle respecte les valeurs spécifiées par l’état, mais peut utiliser la propriété visible ainsi que si l’objet est apparenté dans les états avant/après pour déterminer les valeurs pour animer alpha depuis et vers alphaFrom et alphaTo ne sont pas spécifiés pour l’effet. spark.effects.supportClasses.FadeInstanceFade Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. alphaFrom Valeur initiale de la propriété alpha, comprise entre 0.0 et 1.0, où 0.0 correspond à une transparence et 1.0 à une opacité totale. Valeur initiale de la propriété alpha, comprise entre 0.0 et 1.0, où 0.0 correspond à une transparence et 1.0 à une opacité totale.

Si l’effet fait disparaître le composant cible, la valeur par défaut est la valeur actuelle de la propriété alpha. Si l’effet fait s’afficher le composant cible, la valeur par défaut est 0.0.

alphaTo Valeur finale de la propriété alpha, comprise entre 0.0 et 1.0, où 0.0 correspond à une transparence et 1.0 à une opacité totale. Valeur finale de la propriété alpha, comprise entre 0.0 et 1.0, où 0.0 correspond à une transparence et 1.0 à une opacité totale.

Si l’effet fait disparaître le composant cible, la valeur par défaut est 0.0. Si l’effet fait s’afficher le composant cible, la valeur par défaut est la valeur actuelle de la propriété alpha de la cible.

Animate Cet effet Animate anime un ensemble arbitraire de propriétés entre des valeurs.The <s:Animate> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:Animate
    Properties
    id="ID"
    disableLayout="false"
    easer="{spark.effects.easing.Sine(.5)}"
    interpolator="NumberInterpolator"
    motionPaths="no default"
    repeatBehavior="loop"
  />
]]>mx.effects:Effect Cet effet Animate anime un ensemble arbitraire de propriétés entre des valeurs. Spécifiez les propriétés et valeurs à animer en définissant la propriété motionPaths. spark.effects.supportClasses.AnimateInstanceeffectRepeat Distribué au début de chaque répétition de l’effet, dans le cas d’un effet répété.mx.events.EffectEvent.EFFECT_REPEATmx.events.EffectEvent Distribué au début de chaque répétition de l’effet, dans le cas d’un effet répété. Flex distribue en même temps un événement effectUpdate pour l’effet. effectUpdate Distribué chaque fois que l’effet met à jour la cible.mx.events.EffectEvent.EFFECT_UPDATEmx.events.EffectEvent Distribué chaque fois que l’effet met à jour la cible. Animate Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. disableLayout Si la valeur est true, l’effet désactive la mise en page des conteneurs parent de ses cibles, définissant la propriété autoLayout des conteneurs sur false, et désactive également toute contrainte de mise en page sur les objets cible. false Si la valeur est true, l’effet désactive la mise en page de son objet parent des cibles aux conteneurs, aux conteneurs la définition de la propriété autoLayout sur false, et désactive également une mise en page contrainte sur les objets cible. Ces propriétés seront restaurées lorsque l’effet se termine. easer Comportement d’accélération de cet effet.spark.effects.easing:IEaserspark.effects.easing.Sine(.5) Comportement d’accélération de cet effet. Cet objet IEaser est utilisé pour convertir la partie écoulée de l’animation en partie accélérée, qui est ensuite utilisée pour calculer la valeur au niveau de cette fraction écoulée accélérée.

Remarque : il est possible d’avoir une accélération au niveau de l’effet et au niveau de l’image-clé (où les images-clés contiennent les valeurs/heures utilisées dans les structures d’accélération). Ces comportements d’accélération se construisent les uns sur les autres. Le paramètre easier contrôle l'accélération de l'effet global. Keyframe contrôle l’accélération dans un intervalle de l’animation. Par défaut, l’accélération pour animer est non linéaire (Sine(.5)), tandis que l’option Accélération pour les images Keyframe est linéaire. Si vous souhaitez un effet avec l’accélération au niveau de l’image-clé, vous pouvez choisir de définir l’accélération de l’effet sur linéaire, puis définissez l’option Accélération spécifiquement sur les images Keyframe.

spark.effects.easing.Sineinterpolator Interpolateur utilisé par cet effet pour calculer les valeurs situées entre les valeurs de début et de fin d’une propriété.spark.effects.interpolation:IInterpolator Interpolateur utilisé par cet effet pour calculer les valeurs situées entre les valeurs de début et de fin d’une propriété. Par défaut, la classe NumberInterpolator gère l’interpolation ou, dans les cas où les valeurs de début et de fin sont des tableaux ou des vecteurs, par la classe MultiValueInterpolator. L’interpolation d’autres types ou de valeurs Number devant être interpolées de façon différente, par exemple des valeurs uint contenant des informations de canal de couleur, peut être traitée en spécifiant un autre interpolateur. spark.effects.interpolation.NumberInterpolatorspark.effects.interpolation.MultiValueInterpolatormotionPaths Un vecteur d’objets MotionPath contenant chacun le nom d’une propriété animée et les valeurs prises par la propriété au cours de l’animation. Un vecteur d’objets MotionPath contenant chacun le nom d’une propriété animée et les valeurs prises par la propriété au cours de l’animation. Ce vecteur est prioritaire par rapport aux propriétés déclarées dans les sous-classes de la classe Animate. Par exemple, si ce tableau est défini directement sur un effet Move, toutes les propriétés de l’effet Move, par exemple xFrom, sont ignorées. repeatBehavior Comportement d’un effet répété, c’est-à-dire d’un effet dont la valeur repeatCount est égale à 0 ou supérieure à 1. RepeatBehavior.LOOP Comportement d’un effet répété, c’est-à-dire d’un effet dont la valeur repeatCount est égale à 0 ou supérieure à 1. Cette valeur doit être soit RepeatBehavior.LOOP, auquel cas l’animation est répétée systématiquement dans le même sens, soit RepeatBehavior.REVERSE, auquel cas l’animation est inversée à chaque répétition. Resize L’effet Resize modifie la largeur, la hauteur ou les deux dimensions d’un composant au cours d’un laps de temps spécifié.The <s:Resize> tag inherits all of the tag attributes of its superclass, and adds the following tab attributes:

  <s:Resize
    id="ID"
    widthFrom="val"
    heightFrom="val"
    widthTo="val"
    heightTo="val"
    widthBy="val"
    heightBy="val"
  />
]]>spark.effects:Animate L’effet Resize modifie la largeur, la hauteur ou les deux dimensions d’un composant au cours d’un laps de temps spécifié.

Si vous spécifiez seulement deux des trois valeurs widthFrom, widthTo et widthBy, Flex calcule la troisième valeur. Si vous spécifiez les trois valeurs, Flex ignore la valeur widthBy. Si vous spécifiez uniquement widthBy ou widthTo, la valeur définie pour la propriété widthFrom correspond à la largeur actuelle de l’objet. Il en va de même pour les valeurs des propriétés heightFrom, heightTo et heightBy.

spark.effects.supportClasses.ResizeInstanceResize Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. heightBy Nombre de pixels correspondant à la modification de hauteur du composant. Nombre de pixels correspondant à la modification de hauteur du composant. Les valeurs peuvent être négatives. heightFrom Hauteur initiale, en pixels. Hauteur de départ, en pixels. Si ce paramètre est omis, Flex utilise la hauteur actuelle de la cible. heightTo Hauteur finale de la cible, en pixels. Hauteur finale de la cible, en pixels. widthBy Nombre de pixels correspondant à la modification de largeur de la cible. Nombre de pixels correspondant à la modification de largeur de la cible. Les valeurs peuvent être négatives. widthFrom Largeur initiale de la cible, en pixels. Largeur initiale de la cible, en pixels. Si ce paramètre est omis, Flex utilise la largeur actuelle. widthTo Largeur finale de la cible, en pixels. Largeur finale de la cible, en pixels. Scale L’effet Scale met à l’échelle un objet cible dans les directions x et y autour du centre de transformation.The <s:Scale> tag inherits all of the tag attributes of its of its superclass, and adds the following tag attributes:

  <s:Scale
    id="ID"
    scaleXBy="val"
    scaleXFrom="val"
    scaleXTo="val"
    scaleYBy="val"
    scaleYFrom="val"
    scaleYTo="val"
   />
]]>spark.effects:AnimateTransform L’effet Scale met à l’échelle un objet cible dans les directions x et y autour du centre de transformation. Une échelle de 2.0 signifie que l’objet a été agrandi d’un facteur 2 et une échelle de 0.5 que l’objet a été réduit d’un facteur 2. La valeur de mise à l’échelle 0.0 n’est pas valide.

Comme tous les effets de type AnimateTransform, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement, car il dépend des fonctions de transformation propres à ces classes.

Scale Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. scaleXBy Facteur de mise à l’échelle à appliquer à l’objet dans la direction x. Facteur de mise à l’échelle à appliquer à l’objet dans la direction x. Il s’agit d’un paramètre facultatif pouvant être utilisé à la place de l’une des valeurs de départ et de fin, pour spécifier le delta à ajouter à la valeur de départ ou obtenir la valeur de départ en soustrayant cette valeur de la valeur de fin. scaleXFrom Facteur de mise à l’échelle de départ dans la direction x. Facteur de mise à l’échelle de départ dans la direction x. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleXTo Facteur de mise à l’échelle de fin dans la direction x. Facteur de mise à l’échelle de fin dans la direction x. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleYBy Facteur de mise à l’échelle à appliquer à l’objet dans la direction y. Facteur de mise à l’échelle à appliquer à l’objet dans la direction y. Il s’agit d’un paramètre facultatif pouvant être utilisé à la place de l’une des valeurs de départ et de fin, pour spécifier le delta à ajouter à la valeur de départ ou obtenir la valeur de départ en soustrayant cette valeur de la valeur de fin. scaleYFrom Facteur de mise à l’échelle de départ dans la direction y. Facteur de mise à l’échelle de départ dans la direction y. La valeur de mise à l’échelle 0.0 n’est pas valide. scaleYTo Facteur de mise à l’échelle de fin dans la direction y. Facteur de mise à l’échelle de fin dans la direction y. La valeur de mise à l’échelle 0.0 n’est pas valide. RemoveAction La classe RemoveAction définit un effet d’action correspondant à la propriété RemoveChild d’une définition d’état d’affichage.The <s:RemoveAction> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:RemoveAction
    Properties
    id="ID"
  />
]]>mx.effects:Effect La classe RemoveAction définit un effet d’action correspondant à la propriété RemoveChild d’une définition d’état d’affichage. L’effet RemoveAction peut notamment être utilisé dans une définition de transition pour définir à quel moment de la transition un changement d’état d’affichage défini par une propriété RemoveChild doit se produire. spark.effects.supportClasses.RemoveActionInstancemx.states.RemoveChildRemoveAction Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. SetAction La classe SetAction définit un effet d’action définissant la valeur d’une propriété nommée ou d’un style.The <s:SetAction> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:SetAction
    Properties
    id="ID"
    property=""
    value=""
  />
]]>mx.effects:Effect La classe SetAction définit un effet d’action définissant la valeur d’une propriété nommée ou d’un style. L’effet SetAction peut notamment être utilisé dans une définition de transition pour définir à quel moment de la transition un changement d’état d’affichage défini par un changement de propriété ou de style doit se produire. spark.effects.supportClasses.SetActionInstanceSetAction Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. property Nom de la propriété en cours de modification. Nom de la propriété en cours de modification. value Nouvelle valeur de la propriété. Nouvelle valeur de la propriété. Lorsque cet effet fait partie d’une transition et que la valeur n’est pas spécifiée, Flex détermine la valeur à partir de celle définie par le nouvel état d’affichage. AnimateTransform L’effet AnimateTransform contrôle toutes les animations de transformation des objets cible.The <s:AnimateTransform> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AnimateTransform
    Properties
    id="ID"
    applyChangesPostLayout="false"
    autoCenterTransform="false"
    transformX="0"
    transformY="0"
    transformZ="0"
  />
]]>spark.effects:Animate L’effet AnimateTransform contrôle toutes les animations de transformation des objets cible. Les opérations de transformation (translations, mises à l’échelle, rotation, etc.) sont associées dans des opérations uniques réalisées en parallèle afin d’éviter tout conflit lors de la modification de valeurs de propriété qui se chevauchent. Cet effet fonctionne en regroupant tous les effets de transformation actuels d’une cible au sein d’une occurrence d’effet unique pour cette cible. Autrement dit, plusieurs effets de transformation dans le même effet Parallel sont combinés (les effets de transformation au sein d’une séquence sont exécutés séparément).

Même si la combinaison des différents effets de transformation est réalisée en interne, certaines contraintes doivent être prises en compte :

  • La propriété transformCenter de l’objet cible est appliquée globalement à tous les effets de transformation de cette cible et sa valeur est donc normalement la même sur toutes les cibles.
  • Les effets de transformation ignorent les paramètres de répétition, car les effets d’un seul effet de transformation affectent tous les autres effets de transformation exécutés sur la même cible. Les effets peuvent être répétés en les encapsulant dans un effet CompositeEffect.
  • Les sous-classes de la classe AnimateTransform permettent de réaliser facilement des manipulations simples sur l’effet de transformation. Cependant, pour un contrôle plus approfondi et plus précis des positions temporelles des images-clés et des valeurs sous-jacentes, utilisez directement l’effet AnimateTransform.

Cet effet et ses sous-classes sont soumis à une autre contrainte : la cible doit être de type UIComponent ou GraphicElement (ou une sous-classe de ces classes), ou un objet qui définit et implémente de façon similaire les fonctions transformAround() et transformPointToParent().

Cet effet n’est pas destinée à être utilisés directement, mais expose plutôt les fonctionnalités communes utilisées par les sous-classes. Pour utiliser les effets de transformation, utilisez les effets de sous-classe (Move, Move3D, Scale, Scale3D, Rotate et Rotate3D).

spark.effects.supportClasses.AnimateTransformInstanceAnimateTransform Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. autoCenterTransform Spécifie si l’effet de transformation se produit autour du centre de la cible, (largeur/2, hauteur/2) lorsque l’effet commence la lecture. falsefalse Spécifie si l’effet de transformation se produit autour du centre de la cible, (width/2, height/2) lorsque l’effet commence la lecture. Si l’indicateur n’est pas défini, le centre de la transformation est déterminé par le centre de transformation de l’objet (transformX, transformY, transformZ) et par les propriétés transformX, transformY, transformZ de cet effet. Ainsi, le centre de la transformation correspond au centre de transformation de l’objet cible, où les propriétés transformX, transformY, transformZ sont remplacées par les valeurs définies dans l’effet, le cas échéant. mx.core.UIComponent.transformXmx.core.UIComponent.transformYmx.core.UIComponent.transformZtransformXtransformYtransformZtransformX Définit la coordonnée x du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform. Définit la coordonnée x du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform.

Si la valeur de la propriété autoCenterTransform est false, le centre de la transformation est déterminé par les propriétés transformX, transformY et transformZ de l’objet cible, mais chacune de ces propriétés peut être remplacée en définissant la propriété correspondante dans cet effet.

mx.core.UIComponent.transformXautoCenterTransformtransformY Définit la coordonnée y du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform. Définit la coordonnée y du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform.

Si la valeur de la propriété autoCenterTransform est false, le centre de la transformation est déterminé par les propriétés transformX, transformY et transformZ de l’objet cible, mais chacune de ces propriétés peut être remplacée en définissant la propriété correspondante dans cet effet.

mx.core.UIComponent.transformYautoCenterTransformtransformZ Définit la coordonnée z du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform. Définit la coordonnée z du centre de transformation, sauf si la valeur est remplacée par la propriété autoCenterTransform.

Si la valeur de la propriété autoCenterTransform est false, le centre de la transformation est déterminé par les propriétés transformX, transformY et transformZ de l’objet cible, mais chacune de ces propriétés peut être remplacée en définissant la propriété correspondante dans cet effet.

mx.core.UIComponent.transformZautoCenterTransformapplyChangesPostLayout Les sous-classes de l’effet AnimateTransform utilisent cet indicateur afin de spécifier si l’effet modifie les valeurs de transformation utilisées par le gestionnaire de présentation ou si elle change les valeurs utilisées après l’exécution de la présentation.false Les sous-classes de l’effet AnimateTransform utilisent cet indicateur afin de spécifier si l’effet modifie les valeurs de transformation utilisées par le gestionnaire de présentation ou si elle change les valeurs utilisées après l’exécution de la présentation. AnimateColor L’effet AnimateColor opère un changement de propriété de couleur sur une certaine durée, en réalisant une interpolation entre des valeurs de couleur de départ et de fin, canal par canal.The <s:AnimateColor> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:AnimateColor
    Properties
    id="ID"
    colorFrom="no default"
    colorPropertyName="color"
    colorTo="no default"
  />
]]>spark.effects:Animate L’effet AnimateColor opère un changement de propriété de couleur sur une certaine durée, en réalisant une interpolation entre des valeurs de couleur de départ et de fin, canal par canal. Utilisez cet effet à la place d’Animate ou d’un autre effet lorsque vous souhaitez animer des propriétés de couleur. spark.effects.supportClasses.AnimateColorInstanceAnimateColor Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. colorFrom Valeur de couleur de départ.4.294967295E90xFFFFFF Valeur de couleur de départ. colorPropertyName Nom de la propriété de couleur sur l’objet cible concerné par cette animation.color"color" Nom de la propriété de couleur sur l’objet cible concerné par cette animation. Une propriété de couleur est une propriété acceptant des valeurs de couleur 32 bits. colorTo Valeur de couleur de fin.4.294967295E90xFFFFFF Valeur de couleur de fin. Rotate3D La classe Rotate3D fait pivoter un objet cible en trois dimensions autour des axes x, y ou z. The <s:Rotate3D> tag inherits all of the tag attributes of its superclass, and adds the following tag attributes:

  <s:Rotate3D
    Properties
    id="ID"
    angleXFrom="no default"
    angleXTo="no default"
    angleYFrom="no default"
    angleYTo="no default"
    angleZFrom="no default"
    angleZTo="no default"
  />
]]>spark.effects:AnimateTransform3D La classe Rotate3D fait pivoter un objet cible en trois dimensions autour des axes x, y ou z. La rotation se produit autour du centre de transformation de la cible.

Comme tous les effets de type AnimateTransform, cet effet fonctionne uniquement sur les sous-classes des classes UIComponent et GraphicElement, car il dépend des fonctions de transformation propres à ces classes. Par ailleurs, les effets de transformation s’exécutant en parallèle sur la même cible s’exécutent comme une seule occurrence d’effet. Par conséquent, les effets de transformation partagent le centre de transformation défini par l’un des effets contributeurs.

Rotate3D Constructeur.targetnullObjet à animer à l’aide de cet effet. Constructeur. angleXFrom Angle de départ de la rotation de l’objet cible autour de l’axe x, en degrés. Angle de départ de la rotation de l’objet cible autour de l’axe x, en degrés. Les valeurs possibles vont de 0 à 360. angleXTo Angle de fin de la rotation de l’objet cible autour de l’axe x, en degrés. Angle de fin de la rotation de l’objet cible autour de l’axe x, en degrés. Les valeurs peuvent être soit positives, soit négatives.

Si la valeur de angleTo est inférieure à la valeur de angleFrom, la cible pivote en sens anti-horaire. Dans le cas contraire, elle pivote en sens horaire. Pour faire tourner la cible plusieurs fois, définissez cette valeur sur un grand nombre positif ou sur un petit nombre négatif.

angleYFrom Angle de départ de la rotation de l’objet cible autour de l’axe y, en degrés. Angle de départ de la rotation de l’objet cible autour de l’axe y, en degrés. Les valeurs possibles vont de 0 à 360. angleYTo Angle de fin de la rotation de l’objet cible autour de l’axe y, en degrés. Angle de fin de la rotation de l’objet cible autour de l’axe y, en degrés. Les valeurs peuvent être soit positives, soit négatives.

Si la valeur de angleTo est inférieure à la valeur de angleFrom, la cible pivote en sens anti-horaire. Dans le cas contraire, elle pivote en sens horaire. Pour faire tourner la cible plusieurs fois, définissez cette valeur sur un grand nombre positif ou sur un petit nombre négatif.

angleZFrom Angle de départ de la rotation de l’objet cible autour de l’axe z, en degrés. Angle de départ de la rotation de l’objet cible autour de l’axe z, en degrés. Les valeurs possibles vont de 0 à 360. angleZTo Angle de fin de la rotation de l’objet cible autour de l’axe z, en degrés. Angle de fin de la rotation de l’objet cible autour de l’axe z, en degrés. Les valeurs peuvent être soit positives, soit négatives.

Si la valeur de angleTo est inférieure à la valeur de angleFrom, la cible pivote en sens anti-horaire. Dans le cas contraire, elle pivote en sens horaire. Pour faire tourner la cible plusieurs fois, définissez cette valeur sur un grand nombre positif ou sur un petit nombre négatif.

WipeDirection La classe WipeDirection définit les valeurs de la propriété direction de la classe Wipe.Object La classe WipeDirection définit les valeurs de la propriété direction de la classe Wipe. spark.effects.WipeDOWN Sens d’un balayage commençant en haut et se déplaçant vers le bas. down Sens d’un balayage commençant en haut et se déplaçant vers le bas. LEFT Sens d’un balayage commençant à droite et se déplaçant vers la gauche. left Sens d’un balayage commençant à droite et se déplaçant vers la gauche. RIGHT Sens d’un balayage commençant à gauche et se déplaçant vers la droite. right Sens d’un balayage commençant à gauche et se déplaçant vers la droite. UP Sens d’un balayage commençant en bas et se déplaçant vers le haut. up Sens d’un balayage commençant en bas et se déplaçant vers le haut.