Guide de référence ActionScript® 3.0 pour la plate-forme Adobe® Flash®
Accueil  |  Masquer la liste des packages et des classes |  Packages  |  Classes  |  Nouveautés  |  Index  |  Annexes  |  Pourquoi existe-t-il du contenu en anglais ?
Filtres : AIR 30.0 et versions antérieures, Flash Player 30.0 et versions antérieures, Flash Lite 4
Flex 4.6 et versions antérieures, Flash Pro CS6 et versions antérieures
Masquer les filtres
flash.display 

Graphics  - AS3

Packagesx

Niveau supérieur
adobe.utils
air.desktop
air.net
air.update
air.update.events
coldfusion.air
coldfusion.air.errors
coldfusion.air.events
coldfusion.service
coldfusion.service.events
coldfusion.service.mxml
com.adobe.acm.solutions.authoring.domain.extensions
com.adobe.acm.solutions.ccr.domain.extensions
com.adobe.consulting.pst.vo
com.adobe.dct.component
com.adobe.dct.component.datadictionary
com.adobe.dct.component.datadictionaryElement
com.adobe.dct.component.dataElementsPanel
com.adobe.dct.component.toolbars
com.adobe.dct.event
com.adobe.dct.exp
com.adobe.dct.model
com.adobe.dct.service
com.adobe.dct.service.provider
com.adobe.dct.transfer
com.adobe.dct.util
com.adobe.dct.view
com.adobe.ep.taskmanagement.domain
com.adobe.ep.taskmanagement.event
com.adobe.ep.taskmanagement.filter
com.adobe.ep.taskmanagement.services
com.adobe.ep.taskmanagement.util
com.adobe.ep.ux.attachmentlist.component
com.adobe.ep.ux.attachmentlist.domain
com.adobe.ep.ux.attachmentlist.domain.events
com.adobe.ep.ux.attachmentlist.domain.renderers
com.adobe.ep.ux.attachmentlist.skin
com.adobe.ep.ux.attachmentlist.skin.renderers
com.adobe.ep.ux.content.event
com.adobe.ep.ux.content.factory
com.adobe.ep.ux.content.handlers
com.adobe.ep.ux.content.managers
com.adobe.ep.ux.content.model.asset
com.adobe.ep.ux.content.model.preview
com.adobe.ep.ux.content.model.relation
com.adobe.ep.ux.content.model.search
com.adobe.ep.ux.content.model.toolbar
com.adobe.ep.ux.content.search
com.adobe.ep.ux.content.services
com.adobe.ep.ux.content.services.load
com.adobe.ep.ux.content.services.permissions
com.adobe.ep.ux.content.services.preview
com.adobe.ep.ux.content.services.providers
com.adobe.ep.ux.content.services.query
com.adobe.ep.ux.content.services.relationships
com.adobe.ep.ux.content.services.search.lccontent
com.adobe.ep.ux.content.services.version
com.adobe.ep.ux.content.view
com.adobe.ep.ux.content.view.components.activate
com.adobe.ep.ux.content.view.components.grid
com.adobe.ep.ux.content.view.components.grid.hover
com.adobe.ep.ux.content.view.components.grid.hover.component
com.adobe.ep.ux.content.view.components.grid.renderers
com.adobe.ep.ux.content.view.components.relationships
com.adobe.ep.ux.content.view.components.review
com.adobe.ep.ux.content.view.components.search.renderers
com.adobe.ep.ux.content.view.components.searchpod
com.adobe.ep.ux.content.view.components.toolbar
com.adobe.ep.ux.content.view.components.toolbar.controlRenderers
com.adobe.ep.ux.content.view.components.version
com.adobe.ep.ux.documentsubmit.component
com.adobe.ep.ux.documentsubmit.domain
com.adobe.ep.ux.documentsubmit.skin
com.adobe.ep.ux.taskaction.component
com.adobe.ep.ux.taskaction.domain
com.adobe.ep.ux.taskaction.domain.events
com.adobe.ep.ux.taskaction.skin
com.adobe.ep.ux.taskdetails.component
com.adobe.ep.ux.taskdetails.domain
com.adobe.ep.ux.taskdetails.skin
com.adobe.ep.ux.tasklist.component
com.adobe.ep.ux.tasklist.domain
com.adobe.ep.ux.tasklist.skin
com.adobe.ep.ux.webdocumentviewer.domain
com.adobe.exm.expression
com.adobe.exm.expression.error
com.adobe.exm.expression.event
com.adobe.exm.expression.impl
com.adobe.fiber.runtime.lib
com.adobe.fiber.services
com.adobe.fiber.services.wrapper
com.adobe.fiber.styles
com.adobe.fiber.util
com.adobe.fiber.valueobjects
com.adobe.gravity.binding
com.adobe.gravity.context
com.adobe.gravity.flex.bundleloader
com.adobe.gravity.flex.progress
com.adobe.gravity.flex.serviceloader
com.adobe.gravity.framework
com.adobe.gravity.init
com.adobe.gravity.service.bundleloader
com.adobe.gravity.service.logging
com.adobe.gravity.service.manifest
com.adobe.gravity.service.progress
com.adobe.gravity.tracker
com.adobe.gravity.ui
com.adobe.gravity.utility
com.adobe.gravity.utility.async
com.adobe.gravity.utility.error
com.adobe.gravity.utility.events
com.adobe.gravity.utility.factory
com.adobe.gravity.utility.flex.async
com.adobe.gravity.utility.logging
com.adobe.gravity.utility.message
com.adobe.gravity.utility.sequence
com.adobe.gravity.utility.url
com.adobe.guides.control
com.adobe.guides.domain
com.adobe.guides.i18n
com.adobe.guides.spark.components.skins
com.adobe.guides.spark.components.skins.mx
com.adobe.guides.spark.headers.components
com.adobe.guides.spark.headers.skins
com.adobe.guides.spark.layouts.components
com.adobe.guides.spark.layouts.skins
com.adobe.guides.spark.navigators.components
com.adobe.guides.spark.navigators.renderers
com.adobe.guides.spark.navigators.skins
com.adobe.guides.spark.util
com.adobe.guides.spark.wrappers.components
com.adobe.guides.spark.wrappers.skins
com.adobe.guides.submit
com.adobe.icc.dc.domain
com.adobe.icc.dc.domain.factory
com.adobe.icc.editors.events
com.adobe.icc.editors.handlers
com.adobe.icc.editors.managers
com.adobe.icc.editors.model
com.adobe.icc.editors.model.config
com.adobe.icc.editors.model.el
com.adobe.icc.editors.model.el.operands
com.adobe.icc.editors.model.el.operators
com.adobe.icc.enum
com.adobe.icc.external.dc
com.adobe.icc.obj
com.adobe.icc.services
com.adobe.icc.services.category
com.adobe.icc.services.config
com.adobe.icc.services.download
com.adobe.icc.services.export
com.adobe.icc.services.external
com.adobe.icc.services.formbridge
com.adobe.icc.services.fragmentlayout
com.adobe.icc.services.layout
com.adobe.icc.services.letter
com.adobe.icc.services.locator
com.adobe.icc.services.module
com.adobe.icc.services.render
com.adobe.icc.services.submit
com.adobe.icc.services.user
com.adobe.icc.token
com.adobe.icc.vo
com.adobe.icc.vo.render
com.adobe.icomm.assetplacement.controller
com.adobe.icomm.assetplacement.controller.utils
com.adobe.icomm.assetplacement.data
com.adobe.icomm.assetplacement.model
com.adobe.livecycle.assetmanager.client
com.adobe.livecycle.assetmanager.client.event
com.adobe.livecycle.assetmanager.client.handler
com.adobe.livecycle.assetmanager.client.managers
com.adobe.livecycle.assetmanager.client.model
com.adobe.livecycle.assetmanager.client.model.cms
com.adobe.livecycle.assetmanager.client.service
com.adobe.livecycle.assetmanager.client.service.search
com.adobe.livecycle.assetmanager.client.service.search.cms
com.adobe.livecycle.assetmanager.client.utils
com.adobe.livecycle.content
com.adobe.livecycle.rca.model
com.adobe.livecycle.rca.model.constant
com.adobe.livecycle.rca.model.document
com.adobe.livecycle.rca.model.participant
com.adobe.livecycle.rca.model.reminder
com.adobe.livecycle.rca.model.stage
com.adobe.livecycle.rca.service
com.adobe.livecycle.rca.service.core
com.adobe.livecycle.rca.service.core.delegate
com.adobe.livecycle.rca.service.process
com.adobe.livecycle.rca.service.process.delegate
com.adobe.livecycle.rca.token
com.adobe.livecycle.ria.security.api
com.adobe.livecycle.ria.security.service
com.adobe.mosaic.layouts
com.adobe.mosaic.layouts.dragAndDrop
com.adobe.mosaic.layouts.interfaces
com.adobe.mosaic.mxml
com.adobe.mosaic.om.constants
com.adobe.mosaic.om.events
com.adobe.mosaic.om.impl
com.adobe.mosaic.om.interfaces
com.adobe.mosaic.skinning
com.adobe.mosaic.sparklib.editors
com.adobe.mosaic.sparklib.optionMenu
com.adobe.mosaic.sparklib.scrollableMenu
com.adobe.mosaic.sparklib.scrollableMenu.skins
com.adobe.mosaic.sparklib.tabLayout
com.adobe.mosaic.sparklib.tabLayout.events
com.adobe.mosaic.sparklib.tabLayout.layouts
com.adobe.mosaic.sparklib.tabLayout.skins
com.adobe.mosaic.sparklib.text
com.adobe.mosaic.sparklib.util
com.adobe.solutions.acm.authoring.presentation
com.adobe.solutions.acm.authoring.presentation.actionbar
com.adobe.solutions.acm.authoring.presentation.common
com.adobe.solutions.acm.authoring.presentation.events
com.adobe.solutions.acm.authoring.presentation.fragment
com.adobe.solutions.acm.authoring.presentation.letter
com.adobe.solutions.acm.authoring.presentation.letter.data
com.adobe.solutions.acm.authoring.presentation.preview
com.adobe.solutions.acm.authoring.presentation.rte
com.adobe.solutions.acm.ccr.presentation
com.adobe.solutions.acm.ccr.presentation.contentcapture
com.adobe.solutions.acm.ccr.presentation.contentcapture.events
com.adobe.solutions.acm.ccr.presentation.contentcapture.preview
com.adobe.solutions.acm.ccr.presentation.datacapture
com.adobe.solutions.acm.ccr.presentation.datacapture.renderers
com.adobe.solutions.acm.ccr.presentation.pdf
com.adobe.solutions.exm
com.adobe.solutions.exm.authoring
com.adobe.solutions.exm.authoring.components.controls
com.adobe.solutions.exm.authoring.components.toolbars
com.adobe.solutions.exm.authoring.domain
com.adobe.solutions.exm.authoring.domain.expression
com.adobe.solutions.exm.authoring.domain.impl
com.adobe.solutions.exm.authoring.domain.method
com.adobe.solutions.exm.authoring.domain.variable
com.adobe.solutions.exm.authoring.enum
com.adobe.solutions.exm.authoring.events
com.adobe.solutions.exm.authoring.model
com.adobe.solutions.exm.authoring.renderer
com.adobe.solutions.exm.authoring.view
com.adobe.solutions.exm.expression
com.adobe.solutions.exm.impl
com.adobe.solutions.exm.impl.method
com.adobe.solutions.exm.method
com.adobe.solutions.exm.mock
com.adobe.solutions.exm.mock.method
com.adobe.solutions.exm.runtime
com.adobe.solutions.exm.runtime.impl
com.adobe.solutions.exm.variable
com.adobe.solutions.prm.constant
com.adobe.solutions.prm.domain
com.adobe.solutions.prm.domain.factory
com.adobe.solutions.prm.domain.impl
com.adobe.solutions.prm.domain.manager
com.adobe.solutions.prm.presentation.asset
com.adobe.solutions.prm.presentation.constant
com.adobe.solutions.prm.presentation.document
com.adobe.solutions.prm.presentation.event
com.adobe.solutions.prm.presentation.file
com.adobe.solutions.prm.presentation.project
com.adobe.solutions.prm.presentation.team
com.adobe.solutions.prm.presentation.util
com.adobe.solutions.prm.service
com.adobe.solutions.prm.services.impl
com.adobe.solutions.prm.vo
com.adobe.solutions.rca.constant
com.adobe.solutions.rca.domain
com.adobe.solutions.rca.domain.common
com.adobe.solutions.rca.domain.factory
com.adobe.solutions.rca.domain.impl
com.adobe.solutions.rca.domain.impl.manager
com.adobe.solutions.rca.domain.manager
com.adobe.solutions.rca.presentation
com.adobe.solutions.rca.presentation.comment
com.adobe.solutions.rca.presentation.constant
com.adobe.solutions.rca.presentation.event
com.adobe.solutions.rca.presentation.gantt
com.adobe.solutions.rca.presentation.gantt.ruler
com.adobe.solutions.rca.presentation.template
com.adobe.solutions.rca.presentation.template.audit
com.adobe.solutions.rca.presentation.template.definition
com.adobe.solutions.rca.presentation.template.documents
com.adobe.solutions.rca.presentation.template.stages
com.adobe.solutions.rca.presentation.util
com.adobe.solutions.rca.service
com.adobe.solutions.rca.services.impl
com.adobe.solutions.rca.vo
com.adobe.solutions.rca.vo.um
com.adobe.viewsource
fl.accessibility
fl.containers
fl.controls
fl.controls.dataGridClasses
fl.controls.listClasses
fl.controls.progressBarClasses
fl.core
fl.data
fl.display
fl.events
fl.ik
fl.lang
fl.livepreview
fl.managers
fl.motion
fl.motion.easing
fl.rsl
fl.text
fl.transitions
fl.transitions.easing
fl.video
flash.accessibility
flash.concurrent
flash.crypto
flash.data
flash.desktop
flash.display
flash.display3D
flash.display3D.textures
flash.errors
flash.events
flash.external
flash.filesystem
flash.filters
flash.geom
flash.globalization
flash.html
flash.media
flash.net
flash.net.dns
flash.net.drm
flash.notifications
flash.permissions
flash.printing
flash.profiler
flash.sampler
flash.security
flash.sensors
flash.system
flash.text
flash.text.engine
flash.text.ime
flash.ui
flash.utils
flash.xml
flashx.textLayout
flashx.textLayout.compose
flashx.textLayout.container
flashx.textLayout.conversion
flashx.textLayout.edit
flashx.textLayout.elements
flashx.textLayout.events
flashx.textLayout.factory
flashx.textLayout.formats
flashx.textLayout.operations
flashx.textLayout.utils
flashx.undo
ga.controls
ga.layouts
ga.model
ga.uiComponents
ga.util
ga.views
ga.wrappers
lc.foundation
lc.foundation.domain
lc.foundation.events
lc.foundation.ui
lc.foundation.util
lc.preloader
lc.procmgmt
lc.procmgmt.commands
lc.procmgmt.domain
lc.procmgmt.events
lc.procmgmt.formbridge
lc.procmgmt.impl
lc.procmgmt.ui.attachments
lc.procmgmt.ui.controls
lc.procmgmt.ui.controls.card
lc.procmgmt.ui.controls.renderer
lc.procmgmt.ui.help
lc.procmgmt.ui.layout
lc.procmgmt.ui.presentationmodel
lc.procmgmt.ui.process
lc.procmgmt.ui.search
lc.procmgmt.ui.startpoint
lc.procmgmt.ui.task
lc.procmgmt.ui.task.form
lc.procmgmt.ui.task.form.commands
lc.procmgmt.ui.tracking
mx.accessibility
mx.automation
mx.automation.air
mx.automation.delegates
mx.automation.delegates.advancedDataGrid
mx.automation.delegates.charts
mx.automation.delegates.containers
mx.automation.delegates.controls
mx.automation.delegates.controls.dataGridClasses
mx.automation.delegates.controls.fileSystemClasses
mx.automation.delegates.core
mx.automation.delegates.flashflexkit
mx.automation.events
mx.binding
mx.binding.utils
mx.charts
mx.charts.chartClasses
mx.charts.effects
mx.charts.effects.effectClasses
mx.charts.events
mx.charts.renderers
mx.charts.series
mx.charts.series.items
mx.charts.series.renderData
mx.charts.styles
mx.collections
mx.collections.errors
mx.containers
mx.containers.accordionClasses
mx.containers.dividedBoxClasses
mx.containers.errors
mx.containers.utilityClasses
mx.controls
mx.controls.advancedDataGridClasses
mx.controls.dataGridClasses
mx.controls.listClasses
mx.controls.menuClasses
mx.controls.olapDataGridClasses
mx.controls.scrollClasses
mx.controls.sliderClasses
mx.controls.textClasses
mx.controls.treeClasses
mx.controls.videoClasses
mx.core
mx.core.windowClasses
mx.data
mx.data.crypto
mx.data.errors
mx.data.events
mx.data.messages
mx.data.mxml
mx.data.offline.errors
mx.data.utils
mx.effects
mx.effects.easing
mx.effects.effectClasses
mx.events
mx.filters
mx.flash
mx.formatters
mx.geom
mx.graphics
mx.graphics.codec
mx.graphics.shaderClasses
mx.logging
mx.logging.errors
mx.logging.targets
mx.managers
mx.messaging
mx.messaging.channels
mx.messaging.config
mx.messaging.errors
mx.messaging.events
mx.messaging.management
mx.messaging.messages
mx.modules
mx.netmon
mx.olap
mx.olap.aggregators
mx.preloaders
mx.printing
mx.resources
mx.rpc
mx.rpc.events
mx.rpc.http
mx.rpc.http.mxml
mx.rpc.livecycle
mx.rpc.mxml
mx.rpc.remoting
mx.rpc.remoting.mxml
mx.rpc.soap
mx.rpc.soap.mxml
mx.rpc.wsdl
mx.rpc.xml
mx.skins
mx.skins.halo
mx.skins.spark
mx.skins.wireframe
mx.skins.wireframe.windowChrome
mx.states
mx.styles
mx.utils
mx.validators
org.osmf.containers
org.osmf.display
org.osmf.elements
org.osmf.events
org.osmf.layout
org.osmf.logging
org.osmf.media
org.osmf.metadata
org.osmf.net
org.osmf.net.dvr
org.osmf.net.httpstreaming
org.osmf.net.metrics
org.osmf.net.qos
org.osmf.net.rtmpstreaming
org.osmf.net.rules
org.osmf.traits
org.osmf.utils
spark.accessibility
spark.automation.delegates
spark.automation.delegates.components
spark.automation.delegates.components.gridClasses
spark.automation.delegates.components.mediaClasses
spark.automation.delegates.components.supportClasses
spark.automation.delegates.skins.spark
spark.automation.events
spark.collections
spark.components
spark.components.calendarClasses
spark.components.gridClasses
spark.components.mediaClasses
spark.components.supportClasses
spark.components.windowClasses
spark.core
spark.effects
spark.effects.animation
spark.effects.easing
spark.effects.interpolation
spark.effects.supportClasses
spark.events
spark.filters
spark.formatters
spark.formatters.supportClasses
spark.globalization
spark.globalization.supportClasses
spark.layouts
spark.layouts.supportClasses
spark.managers
spark.modules
spark.preloaders
spark.primitives
spark.primitives.supportClasses
spark.skins
spark.skins.mobile
spark.skins.mobile.supportClasses
spark.skins.spark
spark.skins.spark.mediaClasses.fullScreen
spark.skins.spark.mediaClasses.normal
spark.skins.spark.windowChrome
spark.skins.wireframe
spark.skins.wireframe.mediaClasses
spark.skins.wireframe.mediaClasses.fullScreen
spark.transitions
spark.utils
spark.validators
spark.validators.supportClasses
xd.core.axm.enterprise.view.components
xd.core.axm.enterprise.view.skins
xd.core.axm.view.components
xd.core.axm.view.components.support

Eléments du langage

Constantes globales
Fonctions globales
Opérateurs
Instructions, mots clés et directives
Types spéciaux

Annexes

Nouveautés
Erreurs de compilation
Avertissements du compilateur
Erreurs d’exécution
Migration vers ActionScript 3
Jeux de caractères pris en charge
Balises MXML uniquement
Eléments XML de mouvement
Balises Timed Text
Liste des éléments déconseillés
Constantes d’implémentation d’accessibilité
Utilisation des exemples de code ActionScript
Informations juridiques
Packageflash.display
Classepublic final class Graphics
HéritageGraphics Inheritance Object

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

La classe Graphics contient un ensemble de méthodes permettant de créer une forme vectorielle. Les objets d’affichage qui prennent en charge le dessin incluent les objets Sprite et Shape. Chacune de ces classes comporte une propriété graphics correspondant à un objet Graphics. Vous trouverez ci-dessous quelques-unes des fonctionnalités d’aide à la visualisation qui sont à votre disposition : drawRect(), drawRoundRect(), drawCircle() et drawEllipse().

Il est impossible de créer un objet Graphics directement à partir du code ActionScript. Si vous appelez new Graphics(), une exception est renvoyée.

La classe Graphics ne gère pas les sous-classes.

Consulter les exemples

Plus d’exemples

Informations complémentaires



Propriétés publiques
 PropriétéDéfini par
 Inheritedconstructor : Object
Référence à l’objet de classe ou à la fonction constructeur d’une occurrence donnée d’un objet.
Object
Méthodes publiques
 MéthodeDéfini par
  
beginBitmapFill(bitmap:BitmapData, matrix:Matrix = null, repeat:Boolean = true, smooth:Boolean = false):void
Remplit une zone de tracé en utilisant une image bitmap.
Graphics
  
beginFill(color:uint, alpha:Number = 1.0):void
Spécifie un remplissage simple d’une couleur que des appels ultérieurs à d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) utilisent lors du dessin.
Graphics
  
beginGradientFill(type:String, colors:Array, alphas:Array, ratios:Array, matrix:Matrix = null, spreadMethod:String = "pad", interpolationMethod:String = "rgb", focalPointRatio:Number = 0):void
Spécifie un remplissage en dégradé utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet.
Graphics
  
beginShaderFill(shader:Shader, matrix:Matrix = null):void
Spécifie un remplissage de shader utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet.
Graphics
  
Efface les graphiques dessinés dans l’objet Graphics et réinitialise les réglages de style de trait et de remplissage.
Graphics
  
copyFrom(sourceGraphics:Graphics):void
Copie toutes les commandes de dessin de l’objet Graphics source dans l’objet Graphics appelant.
Graphics
  
cubicCurveTo(controlX1:Number, controlY1:Number, controlX2:Number, controlY2:Number, anchorX:Number, anchorY:Number):void
Trace une courbe de Bézier cubique de la position de dessin actuelle au point d’ancrage spécifié.
Graphics
  
curveTo(controlX:Number, controlY:Number, anchorX:Number, anchorY:Number):void
Trace une courbe de Bézier quadratique entre la position actuelle et la position (anchorX, anchorY), en utilisant le style de trait actuel et le point de contrôle spécifié par les coordonnées (controlX, controlY).
Graphics
  
Dessine un cercle.
Graphics
  
drawEllipse(x:Number, y:Number, width:Number, height:Number):void
Dessine une ellipse.
Graphics
  
Soumet une série d’occurrences IGraphicsData pour le dessin.
Graphics
  
drawPath(commands:Vector.<int>, data:Vector.<Number>, winding:String = "evenOdd"):void
Soumet une série de commandes pour le dessin.
Graphics
  
drawRect(x:Number, y:Number, width:Number, height:Number):void
Dessine un rectangle.
Graphics
  
drawRoundRect(x:Number, y:Number, width:Number, height:Number, ellipseWidth:Number, ellipseHeight:Number = NaN):void
Dessine un rectangle arrondi.
Graphics
  
drawTriangles(vertices:Vector.<Number>, indices:Vector.<int> = null, uvtData:Vector.<Number> = null, culling:String = "none"):void
Restitue un ensemble de triangles, généralement pour déformer les images bitmap et leur donner un aspect tridimensionnel.
Graphics
  
Applique un remplissage aux lignes et aux courbes ajoutées depuis le dernier appel de la méthode beginFill(), beginGradientFill() ou beginBitmapFill().
Graphics
 Inherited
Indique si la propriété spécifiée d’un objet est définie.
Object
 Inherited
Indique si une occurrence de la classe Object figure dans la chaîne de prototype de l’objet spécifié en tant que paramètre.
Object
  
lineBitmapStyle(bitmap:BitmapData, matrix:Matrix = null, repeat:Boolean = true, smooth:Boolean = false):void
Spécifie une image bitmap à utiliser pour le trait lors du traçage des lignes.
Graphics
  
lineGradientStyle(type:String, colors:Array, alphas:Array, ratios:Array, matrix:Matrix = null, spreadMethod:String = "pad", interpolationMethod:String = "rgb", focalPointRatio:Number = 0):void
Spécifie le dégradé à utiliser pour le trait lors du tracé des lignes.
Graphics
  
lineShaderStyle(shader:Shader, matrix:Matrix = null):void
Spécifie un shader à utiliser pour le trait lors du traçage des lignes.
Graphics
  
lineStyle(thickness:Number = NaN, color:uint = 0, alpha:Number = 1.0, pixelHinting:Boolean = false, scaleMode:String = "normal", caps:String = null, joints:String = null, miterLimit:Number = 3):void
Spécifie le style de ligne utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle().
Graphics
  
Trace une ligne en utilisant le style de trait actuel à partir de la position de dessin actuelle jusqu’à (x, y) ; la position de dessin actuelle est ensuite définie sur (x, y).
Graphics
  
Déplace la position de dessin actuelle vers (x, y).
Graphics
 Inherited
Indique si la propriété spécifiée existe et est énumérable.
Object
  
Interroge un objet Sprite ou Shape (et éventuellement ses enfants) sur son contenu graphique vectoriel.
Graphics
 Inherited
Définit la disponibilité d’une propriété dynamique pour les opérations en boucle.
Object
 Inherited
Renvoie la représentation de chaîne de cet objet, formatée selon les paramètres régionaux en vigueur.
Object
 Inherited
Renvoie la représentation sous forme de chaîne de l’objet spécifié.
Object
 Inherited
Renvoie la valeur primitive de l’objet spécifié.
Object
Détails de la méthode

beginBitmapFill

()méthode
public function beginBitmapFill(bitmap:BitmapData, matrix:Matrix = null, repeat:Boolean = true, smooth:Boolean = false):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Remplit une zone de tracé en utilisant une image bitmap. L’image bitmap peut être répétée ou former une mosaïque afin de remplir la zone. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

bitmap:BitmapData — Image bitmap transparente ou opaque qui contient les bits à afficher.
 
matrix:Matrix (default = null) — Objet matrix (appartenant à la classe flash.geom.Matrix), qui permet de définir les transformations de l’image bitmap. Par exemple, vous pouvez utiliser la matrice suivante pour faire pivoter une image bitmap de 45 degrés (pi/4 radians) :
     matrix = new flash.geom.Matrix(); 
     matrix.rotate(Math.PI / 4);
     
 
repeat:Boolean (default = true) — Si la valeur est true, l’image bitmap se reproduit pour former un motif. Si la valeur est false, l’image bitmap ne se répète pas et les bords de l’image sont utilisés pour tout remplissage qui dépasse l’image.

Considérons par exemple l’image bitmap suivante (un motif en damier de 20 x 20 pixels) :

damier de 20x20 pixels

Lorsque la propriété repeat est définie sur true (comme dans l’exemple suivant), le remplissage bitmap répète l’image bitmap :

damier de 60x60 pixels

Lorsque la propriété repeat est définie sur false, le remplissage bitmap utilise les pixels du bord pour le remplissage en dehors de l’image bitmap :

image de 60x60 pixels sans répétition

 
smooth:Boolean (default = false) — Si la valeur est false, les images bitmap agrandies sont rendues en appliquant un algorithme d’approximation et ont un aspect pixélisé. Si la valeur est true, les images bitmap agrandies sont rendues avec un algorithme bilinéaire. Les rendus qui résultent de l’utilisation de l’algorithme d’approximation sont plus rapides.

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant utilise une image (image1.jpg), pivotée et répétée pour remplir un rectangle.
  1. Le fichier image (image1.jpg) est chargé via les objets Loader et URLRequest. Ici, le fichier est dans le même répertoire que le fichier SWF. Le fichier SWF doit être compilé avec la Protection de lecture locale définie sur Accéder aux fichiers locaux seulement.
  2. Dès que l’image est chargée (à la fin de l’événement), la méthode drawImage() est appelée. La méthode ioErrorHandler() écrit un commentaire de suivi si l’image n’a pas été chargée correctement.
  3. Dans la méthode drawImage(), un objet BitmapData est instancié et sa largeur et sa largeur sont définies en fonction de l’image (image1.jpg). L’image source est ensuite dessinée dans l’objet BitmapData. Ensuite, un rectangle est tracé dans l’objet Sprite mySprite et l’objet BitmapData est utilisé pour le remplir. A l’aide d’un objet Matrix, la méthode beginBitmapFill() fait pivoter l’image de 45 degrés, puis commence à remplir le rectangle avec l’image jusqu’à ce qu’il soit terminé.
package {
    import flash.display.Sprite;
    import flash.display.BitmapData;
    import flash.display.Loader;
    import flash.net.URLRequest;
    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.geom.Matrix;

    public class Graphics_beginBitmapFillExample extends Sprite {
 
        private var url:String = "image1.jpg";
        private var loader:Loader = new Loader();

        public function Graphics_beginBitmapFillExample() {

            var request:URLRequest = new URLRequest(url);
            
            loader.load(request);
            loader.contentLoaderInfo.addEventListener(Event.COMPLETE, drawImage);
            loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
        }

        private function drawImage(event:Event):void {

            var mySprite:Sprite = new Sprite();
            var myBitmap:BitmapData = new BitmapData(loader.width, loader.height, false);
  
            myBitmap.draw(loader, new Matrix());
            
            var matrix:Matrix = new Matrix();
            matrix.rotate(Math.PI/4);
            
            mySprite.graphics.beginBitmapFill(myBitmap, matrix, true);
            mySprite.graphics.drawRect(100, 50, 200, 90);
            mySprite.graphics.endFill();
            
            addChild(mySprite);
        }
 
         private function ioErrorHandler(event:IOErrorEvent):void {
            trace("Unable to load image: " + url);
        }
    }   
}

beginFill

()méthode 
public function beginFill(color:uint, alpha:Number = 1.0):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie un remplissage simple d’une couleur que des appels ultérieurs à d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) utilisent lors du dessin. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

color:uint — Couleur du remplissage (0xRRGGBB).
 
alpha:Number (default = 1.0) — Valeur alpha du remplissage (de 0.0 à 1.0).

Eléments de l’API associés


Exemple
Comment utiliser cet exemple
Pour une illustration de l’utilisation de cette méthode, voir l’exemple présenté à la fin de ce cours.

beginGradientFill

()méthode 
public function beginGradientFill(type:String, colors:Array, alphas:Array, ratios:Array, matrix:Matrix = null, spreadMethod:String = "pad", interpolationMethod:String = "rgb", focalPointRatio:Number = 0):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie un remplissage en dégradé utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

type:String — Valeur de la classe GradientType qui spécifie le type de dégradé à utiliser : GradientType.LINEAR ou GradientType.RADIAL.
 
colors:Array — Tableau de valeurs de couleurs RVB hexadécimales utilisé pour le dégradé (par exemple, rouge correspond à 0xFF0000, bleu à 0x0000FF, etc.). Vous pouvez définir jusqu’à 15 couleurs. Pour chaque couleur, définissez une valeur correspondante dans les paramètres alphas et ratios.
 
alphas:Array — Tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs disponibles sont comprises entre 0 et 1. Si la valeur est inférieure à 0, la valeur par défaut est de 0. Si la valeur est supérieure à 1, la valeur par défaut est de 1.
 
ratios:Array — Tableau de taux de distribution des couleurs ; les valeurs disponibles sont comprises entre 0 et 255. Cette valeur définit le pourcentage de la largeur où la couleur est échantillonnée sur 100 %. La valeur 0 représente la position de gauche dans la zone de dégradés, tandis que 255 représente la position de droite.

Remarque : cette valeur représente les positions de la zone de dégradés, plutôt que l’espace de coordonnées du dégradé final, susceptible d’être plus large ou plus étroit que la zone de dégradés. Spécifiez une valeur pour chaque valeur dans le paramètre colors.

Par exemple, pour un dégradé linéaire qui comprend deux couleurs, bleu et vert, l’exemple suivant illustre l’emplacement des couleurs dans le dégradé selon les différentes valeurs du tableau ratios :

ratiosDégradé
[0, 127]dégradé linéaire du bleu au vert avec des taux de 0 et 127
[0, 255]dégradé linéaire du bleu au vert avec des taux de 0 et 255
[127, 255]dégradé linéaire du bleu au vert avec des taux de 127 et 255

Les valeurs du tableau doivent augmenter de manière séquentielle ; par exemple, [0, 63, 127, 190, 255].

 
matrix:Matrix (default = null) — Matrice de transformation définie par la classe flash.geom.Matrix. La classe flash.geom.Matrix inclut une méthode createGradientBox(), qui permet de configurer facilement la matrice en vue de son utilisation avec la méthode beginGradientFill().
 
spreadMethod:String (default = "pad") — Valeur de la classe SpreadMethod qui spécifie la méthode d’étalement à utiliser : SpreadMethod.PAD, SpreadMethod.REFLECT ou SpreadMethod.REPEAT.

Par exemple, considérons un dégradé linéaire simple entre deux couleurs :

     import flash.geom.*
     import flash.display.*
     var fillType:String = GradientType.LINEAR;
     var colors:Array = [0xFF0000, 0x0000FF];
     var alphas:Array = [1, 1];
     var ratios:Array = [0x00, 0xFF];
     var matr:Matrix = new Matrix();
     matr.createGradientBox(20, 20, 0, 0, 0);
     var spreadMethod:String = SpreadMethod.PAD;
     this.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod);        
     this.graphics.drawRect(0,0,100,100);
     

Cet exemple utilise SpreadMethod.PAD comme méthode d’étalement, et le remplissage en dégradé prend l’aspect suivant :

dégradé linéaire avec SpreadMethod.PAD

Si vous utilisez SpreadMethod.REFLECT comme méthode d’étalement, le remplissage en dégradé prend l’aspect suivant :

dégradé linéaire avec SpreadMethod.REFLECT

Si vous utilisez SpreadMethod.REPEAT comme méthode d’étalement, le remplissage en dégradé prend l’aspect suivant :

dégradé linéaire avec SpreadMethod.REPEAT

 
interpolationMethod:String (default = "rgb") — Valeur de la classe InterpolationMethod qui spécifie la valeur à utiliser : InterpolationMethod.LINEAR_RGB ou InterpolationMethod.RGB

Prenons, par exemple, un dégradé linéaire simple entre deux couleurs (le paramètre spreadMethod étant réglé sur SpreadMethod.REFLECT). Les différentes méthodes d’interpolation influent sur l’aspect de la façon suivante :

dégradé linéaire avec InterpolationMethod.LINEAR_RGB dégradé linéaire avec InterpolationMethod.RGB
InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB
 
focalPointRatio:Number (default = 0) — Nombre qui contrôle l’emplacement du point focal du dégradé. La valeur 0 signifie que le point focal est au centre. La valeur 1 signifie que le point focal est au bord du cercle du dégradé. La valeur -1 signifie que le point focal est sur l’autre bord du cercle du dégradé. Toute valeur inférieure à -1 ou supérieure à 1 est arrondie à -1 ou 1. Par exemple, l’exemple suivant affiche un paramètre focalPointRatio défini sur 0,75 :

dégradé linéaire avec focalPointRatio défini sur 0.75


Valeur émise
ArgumentError — Si le paramètre type n’est pas valide.

Plus d’exemples

Eléments de l’API associés

beginShaderFill

()méthode 
public function beginShaderFill(shader:Shader, matrix:Matrix = null):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Spécifie un remplissage de shader utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Les remplissages de shader ne sont pas pris en charge sous le rendu sur GPU ; les zones remplies prendront la couleur cyan.

Paramètres

shader:Shader — Shader à utiliser pour le remplissage. Cette occurrence Shader n’est pas obligatoire pour spécifier une entrée d’image. Toutefois, si une entrée d’image est spécifiée dans le shader, elle doit être fournie manuellement. Pour spécifier l’entrée, définissez la propriété input de la propriété ShaderInput correspondante de la propriété Shader.data.

Lorsque vous transmettez une occurrence Shader sous forme d’argument, le shader est copié en interne. L’opération de remplissage utilise cette copie interne et non une référence au shader d’origine. Toute modification apportée au shader, par exemple la modification de la valeur d’un paramètre, l’entrée ou le pseudo-code binaire, n’est pas appliquée au shader copié utilisé pour le remplissage.

 
matrix:Matrix (default = null) — Objet matrice (de la classe flash.geom.Matrix), que vous pouvez utiliser pour définir des transformations sur le shader. Par exemple, vous pouvez utiliser la matrice suivante pour faire pivoter un shader de 45 degrés (pi/4 radians) :
     matrix = new flash.geom.Matrix(); 
     matrix.rotate(Math.PI / 4);
     

Les coordonnées reçues dans le shader sont basées sur la matrice spécifiée dans le paramètre matrix. Dans le cas d’une matrice par défaut (null), les coordonnées dans le shader sont en coordonnées de pixel locales qui peuvent être utilisées pour échantillonner une entrée.


Valeur émise
ArgumentError — Lorsque le type de sortie du shader n’est pas compatible avec cette opération (le shader doit spécifier une sortie pixel3 ou pixel4).
 
ArgumentError — Lorsque le shader spécifie une entrée d’image non fournie.
 
ArgumentError — Lorsqu’une occurrence de ByteArray ou de Vector.<Number> est utilisée comme entrée et les propriétés width et height ne sont pas spécifiées pour le ShaderInput, ou les valeurs spécifiées ne correspondent pas à la quantité de données dans l’objet d’entrée. Voir la propriété ShaderInput.input pour plus d’informations.

Plus d’exemples

Eléments de l’API associés

clear

()méthode 
public function clear():void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Efface les graphiques dessinés dans l’objet Graphics et réinitialise les réglages de style de trait et de remplissage.

copyFrom

()méthode 
public function copyFrom(sourceGraphics:Graphics):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5, Flash Lite 4

Copie toutes les commandes de dessin de l’objet Graphics source dans l’objet Graphics appelant.

Paramètres

sourceGraphics:Graphics — Objet Graphics à partir duquel les commandes de dessin doivent être copiées.

cubicCurveTo

()méthode 
public function cubicCurveTo(controlX1:Number, controlY1:Number, controlX2:Number, controlY2:Number, anchorX:Number, anchorY:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 11, AIR 3

Trace une courbe de Bézier cubique de la position de dessin actuelle au point d’ancrage spécifié. Les courbes de Bézier cubiques comprennent deux points d’ancrage et deux points de contrôle. La courbe interpole les deux points d’ancrage et s’incurve en direction des points de contrôle.

Bézier cubique

Les quatre points à utiliser pour tracer une courbe de Bézier cubique avec la méthode cubicCurveTo() sont les suivants :

  • La position de dessin actuelle est le premier point d’ancrage.
  • Les paramètres anchorX et anchorY spécifient le deuxième point d’ancrage.
  • Les paramètres controlX1 et controlY1 spécifient le premier point de contrôle.
  • Les paramètres controlX2 et controlY2 spécifient le deuxième point de contrôle.

Si vous appelez la méthode cubicCurveTo() avant d’appeler la méthode moveTo(), votre courbe commence à la position (0, 0).

Si l’appel de la méthode cubicCurveTo() aboutit, le moteur d’exécution de Flash définit la position de dessin actuelle sur (anchorX, anchorY). Si l’appel de la méthode cubicCurveTo() échoue, la position de dessin actuelle n’est pas modifiée.

Si votre clip contient du contenu créé à l’aide des outils de dessin de Flash, les résultats d’appels des méthodes cubicCurveTo() sont tracés sous ce contenu.

Paramètres

controlX1:Number — Spécifie la position horizontale du premier point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
controlY1:Number — Spécifie la position verticale du premier point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
controlX2:Number — Spécifie la position horizontale du deuxième point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
controlY2:Number — Spécifie la position verticale du deuxième point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
anchorX:Number — Spécifie la position horizontale du point d’ancrage par rapport au point d’alignement de l’objet d’affichage parent.
 
anchorY:Number — Spécifie la position verticale du point d’ancrage par rapport au point d’alignement de l’objet d’affichage parent.


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant dessine un objet circulaire bleu avec une largeur et une hauteur de 100 pixels, 250 pixels à droite du point d’alignement (0, 0) de l’objet d’affichage Sprite.

Trace quatre courbes pour produire un cercle et le remplir en bleu.

Notez que, du fait de la nature de l’équation Bézier cubique, ce n’est pas un cercle parfait. La meilleure façon de tracer un cercle est d’utiliser la méthode drawCircle() de la classe Graphics.

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    
    public class Graphics_cubicCurveToExample extends Sprite
    {
        public function Graphics_cubicCurveToExample():void
        {
            var rounderObject:Shape = new Shape();

            rounderObject.graphics.beginFill(0x0000FF);
            rounderObject.graphics.moveTo(250, 0);
            rounderObject.graphics.cubicCurveTo(275, 0, 300, 25, 300, 50);
            rounderObject.graphics.cubicCurveTo(300, 75, 275, 100, 250, 100);
            rounderObject.graphics.cubicCurveTo(225, 100, 200, 75, 200, 50);
            rounderObject.graphics.cubicCurveTo(200, 25, 225, 0, 250, 0);
            rounderObject.graphics.endFill();
            
            this.addChild(rounderObject);
        }
    }
}

curveTo

()méthode 
public function curveTo(controlX:Number, controlY:Number, anchorX:Number, anchorY:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Trace une courbe de Bézier quadratique entre la position actuelle et la position (anchorX, anchorY), en utilisant le style de trait actuel et le point de contrôle spécifié par les coordonnées (controlX, controlY). La position de dessin actuelle est ensuite définie sur (anchorX, anchorY). Si le clip dans lequel vous dessinez intègre du contenu créé à l’aide des outils de dessin Flash, les appels de la méthode curveTo() sont tracés sous le contenu. Si vous appelez la méthode curveTo() avant d’appeler la méthode moveTo(), la position de dessin actuelle prend par défaut la valeur (0, 0). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

La courbe dessinée est une courbe de Bézier quadratique. Les courbes de Bézier quadratiques comprennent deux points d’ancrage et un point de contrôle. La courbe interpole les deux points d’ancrage et s’incurve en direction du point de contrôle.

Bézier quadratique

Paramètres

controlX:Number — Nombre qui spécifie la position horizontale du point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
controlY:Number — Nombre qui spécifie la position verticale du point de contrôle par rapport au point d’alignement de l’objet d’affichage parent.
 
anchorX:Number — Nombre qui spécifie la position horizontale du point d’ancrage suivant par rapport au point d’alignement de l’objet d’affichage parent.
 
anchorY:Number — Nombre qui spécifie la position verticale du point d’ancrage suivant par rapport au point d’alignement de l’objet d’affichage parent.


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant dessine un objet circulaire vert avec une largeur et une hauteur de 100 pixels, 250 pixels à droite du point d’alignement (0, 0) de l’objet d’affichage Sprite.

Trace quatre courbes pour produire un cercle et le remplir en vert.

Notez que, du fait de la nature quadratique de l’équation Bézier, ce n’est pas un cercle parfait. La meilleure façon de tracer un cercle est d’utiliser la méthode drawCircle() de la classe Graphics.

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    
    public class Graphics_curveToExample1 extends Sprite
    {
        public function Graphics_curveToExample1():void
        {
            var roundObject:Shape = new Shape();

            roundObject.graphics.beginFill(0x00FF00);
            roundObject.graphics.moveTo(250, 0);
            roundObject.graphics.curveTo(300, 0, 300, 50);
            roundObject.graphics.curveTo(300, 100, 250, 100);
            roundObject.graphics.curveTo(200, 100, 200, 50);
            roundObject.graphics.curveTo(200, 0, 250, 0);
            roundObject.graphics.endFill();
            
            this.addChild(roundObject);
        }
    }
}

L’exemple suivant trace une nouvelle lune à l’aide de la méthode curveTo().

Deux lignes courbes de 1 pixel sont tracées et l’espace qui les sépare est rempli en blanc. La méthode moveTo() est utilisée pour placer la position du dessin en cours aux coordonnées (100, 100). La première courbe déplace la position du dessin sur (100, 200), son point de destination. La seconde courbe retourne à la position d’origine (100, 100), son point de destination. Les points de contrôle horizontaux déterminent les différentes tailles des courbes.

package {
    import flash.display.Sprite;
    import flash.display.Shape;

    public class Graphics_curveToExample2 extends Sprite
    {
        public function Graphics_curveToExample2() {
            var newMoon:Shape = new Shape();
            
            newMoon.graphics.lineStyle(1, 0);
            newMoon.graphics.beginFill(0xFFFFFF);
            newMoon.graphics.moveTo(100, 100); 
            newMoon.graphics.curveTo(30, 150, 100, 200);    
            newMoon.graphics.curveTo(50, 150, 100, 100);
            graphics.endFill();
            
            this.addChild(newMoon);
        }
    }
}

drawCircle

()méthode 
public function drawCircle(x:Number, y:Number, radius:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Dessine un cercle. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawCircle(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

x:Number — Position x du centre du cercle par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Coordonnée y du centre du cercle par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
radius:Number — Rayon du cercle (en pixels).

Eléments de l’API associés


Exemple
Comment utiliser cet exemple
Pour une illustration de l’utilisation de cette méthode, voir l’exemple présenté à la fin de ce cours.

drawEllipse

()méthode 
public function drawEllipse(x:Number, y:Number, width:Number, height:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Dessine une ellipse. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawEllipse(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

x:Number — Position x de la partie supérieure gauche du cadre de sélection de l’ellipse par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Coordonnée y de la partie supérieure gauche du cadre de sélection de l’ellipse par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
width:Number — Largeur de l’ellipse (en pixels).
 
height:Number — Hauteur de l’ellipse (en pixels).

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant utilise la fonction drawEgg() pour tracer trois œufs de tailles différentes (trois tailles d’ovale), en fonction du paramètre eggSize.
  1. Le constructeur appelle la fonction drawEgg() et transmet les paramètres horizontaux et verticaux d’emplacement du traçage des œufs, plus le type d’œuf (eggSize) (la hauteur et la largeur des œufs (les ovales) peuvent être utilisées pour décider de l’emplacement où ils doivent s’afficher).
  2. La fonction drawEgg() trace les ovales de tailles différentes et les remplit à l’aide de la méthode beginFill(). Aucune gestion d’erreur avancée n’a été écrite pour sa fonction.
package {
    import flash.display.Sprite;
    import flash.display.Shape;

    public class Graphics_drawEllipseExample extends Sprite
    {
        public static const SMALL:uint = 0;
        public static const MEDIUM:uint = 1;
        public static const LARGE:uint = 2;

        public function Graphics_drawEllipseExample()
        {
            drawEgg(SMALL, 0, 100);
            drawEgg(MEDIUM, 100, 60);
            drawEgg(LARGE, 250, 35);    
        }

        public function drawEgg(eggSize:uint, x:Number, y:Number):void  {
            
            var myEgg:Shape = new Shape();
            
            myEgg.graphics.beginFill(0xFFFFFF);
            myEgg.graphics.lineStyle(1);

            switch(eggSize) {
                case SMALL:
                    myEgg.graphics.drawEllipse(x, y, 60, 70);
                    break;
                case MEDIUM:
                    myEgg.graphics.drawEllipse(x, y, 120, 150);    
                    break;
                case LARGE:
                    myEgg.graphics.drawEllipse(x, y, 150, 200);
                    break;
                default:
                    trace ("Wrong size! There is no egg.");
                break;            
            }
            
            myEgg.graphics.endFill();
    
            this.addChild(myEgg);
        }
    }
}

drawGraphicsData

()méthode 
public function drawGraphicsData(graphicsData:Vector.<IGraphicsData>):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Soumet une série d’occurrences IGraphicsData pour le dessin. Cette méthode accepte un objet Vector contenant des objets, y compris des tracés, des remplissages et des traits, qui implémentent l’interface IGraphicsData. Un objet Vector des occurrences IGraphicsData peut se reporter à une forme ou à un jeu de données complexe et complètement défini pour restituer une forme complète.

Les tracés des graphiques peuvent contenir d’autres tracés de graphiques. Si le vecteur graphicsData inclut un tracé, ce dernier et tous ses sous-tracés sont restitués au cours de cette opération.

Paramètres

graphicsData:Vector.<IGraphicsData> — Objet Vector contenant des objets graphiques, dont chacun doit implémenter l’interface IGraphicsData.

Plus d’exemples

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant crée un objet GraphicsGradientFill pour établir les propriétés de remplissage d’un carré. Ensuite, l’exemple crée un objet GraphicsStroke (pour l’épaisseur des lignes) ainsi qu’un objet GraphicsSolidFill (pour la couleur des lignes) afin de définir les propriétés de la ligne de bordure du carré. L’exemple crée alors un objet GraphicsPath qui contient les valeurs permettant de dessiner la forme. Tous ces objets sont stockés dans un objet IGraphicsData et transmis à la commande drawGraphicsData() pour effectuer le rendu de la forme.
package
{
    import flash.display.*;
    import flash.geom.*;

    public class DrawGraphicsDataExample extends Sprite
    {
        public function DrawGraphicsDataExample()
        {
            // establish the fill properties
            var myFill:GraphicsGradientFill = new GraphicsGradientFill();
            myFill.colors = [0xEEFFEE, 0x0000FF];
            myFill.matrix = new Matrix();
            myFill.matrix.createGradientBox(100, 100, 0);
            
            // establish the stroke properties
            var myStroke:GraphicsStroke = new GraphicsStroke(2);
            myStroke.fill = new GraphicsSolidFill(0x000000);
            
            // establish the path properties
            var pathCommands = new Vector.<int>(5, true);
            pathCommands[0] = GraphicsPathCommand.MOVE_TO;
            pathCommands[1] = GraphicsPathCommand.LINE_TO;
            pathCommands[2] = GraphicsPathCommand.LINE_TO;
            pathCommands[3] = GraphicsPathCommand.LINE_TO;
            pathCommands[4] = GraphicsPathCommand.LINE_TO;
            
            var pathCoordinates:Vector.<Number> = new Vector.<Number>(10, true);
            pathCoordinates.push(10,10, 10,100, 100,100, 100,10, 10,10);
            
            var myPath:GraphicsPath = new GraphicsPath(pathCommands, pathCoordinates);
            
            // populate the IGraphicsData Vector array
            var myDrawing:Vector.<IGraphicsData> = new Vector.<IGraphicsData>(3, true);
            myDrawing[0] = myFill;
            myDrawing[1] = myStroke;
            myDrawing[2] = myPath;
            
            // render the drawing
            graphics.drawGraphicsData(myDrawing);
        }
    }
}

drawPath

()méthode 
public function drawPath(commands:Vector.<int>, data:Vector.<Number>, winding:String = "evenOdd"):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Soumet une série de commandes pour le dessin. La méthode drawPath() accepte un vecteur de commandes de dessin individuelles moveTo(), lineTo() et curveTo() et les combine dans un seul appel. Les paramètres de la méthode drawPath() associent des commandes de dessin comportant des paires de valeurs de coordonnées x et y à une direction de dessin. Les commandes de dessin sont des entiers, représentés comme des constantes définies par la classe GraphicsPathCommand. Les paires de valeurs des coordonnées x et y sont des nombres dans un tableau où chaque paire définit un emplacement de coordonnée. La direction de dessin est une valeur issue de la classe GraphicsPathWinding.

En général, le rendu des dessins sera plus rapide avec la méthode drawPath() qu’avec une série d’appels de méthode individuels lineTo() et curveTo().

La méthode drawPath() utilise un calcul en virgule flottante afin que la rotation et la mise à l’échelle des formes soient plus précises et donnent de meilleurs résultats. Toutefois, les courbes soumises à l’aide de la méthode drawPath() peuvent comporter de petites erreurs d’alignement des sous-pixels lorsqu’elles sont utilisées en conjonction avec les méthodes lineTo() et curveTo().

La méthode drawPath() utilise également des règles légèrement différentes pour le remplissage et le dessin des lignes. Voici ces règles :

  • Lorsqu’un remplissage est appliqué au rendu d’un tracé :
    • Tout sous-tracé de moins de 3 points n’est pas rendu (cependant, le rendu du trait se produira tout de même, en respectant les règles des traits ci-dessous).
    • Tout sous-tracé qui n’est pas clos (le point de fin n’est pas égal au point de début) est fermé implicitement.
  • Lorsqu’un trait est appliqué au rendu d’un tracé :
    • Les sous-tracés peuvent être composés de tout nombre de points.
    • Le sous-tracé n’est jamais implicitement fermé.

Paramètres

commands:Vector.<int> — Vecteur d’entiers représentant des commandes de dessin. L’ensemble des valeurs acceptées est défini par les constantes de la classe GraphicsPathCommand.
 
data:Vector.<Number> — Vecteur d’occurrences de Number où chaque paire de nombres est traitée comme un emplacement de coordonnées (paire x, y). Les valeurs des coordonnées x et y ne sont pas des objets Point ; le vecteur data correspond à une série de nombres où chaque groupe de deux nombres représente l’emplacement d’une coordonnée.
 
winding:String (default = "evenOdd") — Spécifie la règle d’enroulement à l’aide d’une valeur définie dans la classe GraphicsPathWinding.

Plus d’exemples

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant remplit deux objets Vector, puis les transmet à la méthode drawPath() pour obtenir une étoile bleue. Le premier vecteur, star_commands, contient une série de constantes représentant des commandes de dessin de la classe GraphicsPathCommand. Le deuxième objet Vector, star_coord, contient 5 jeux de paires de coordonnées x et y. La méthode drawPath() fait correspondre les commandes avec les positions afin de dessiner une étoile.
package
{
    import flash.display.*;
        
    public class DrawPathExample extends Sprite
    {
        public function DrawPathExample()
        {
            var star_commands:Vector.<int> = new Vector.<int>(5, true);
            
            star_commands[0] = GraphicsPathCommand.MOVE_TO;
            star_commands[1] = GraphicsPathCommand.LINE_TO;
            star_commands[2] = GraphicsPathCommand.LINE_TO;
            star_commands[3] = GraphicsPathCommand.LINE_TO;
            star_commands[4] = GraphicsPathCommand.LINE_TO;
            
            var star_coord:Vector.<Number> = new Vector.<Number>(10, true);
            star_coord[0] = 66; //x
            star_coord[1] = 10; //y 
            star_coord[2] = 23; 
            star_coord[3] = 127; 
            star_coord[4] = 122; 
            star_coord[5] = 50; 
            star_coord[6] = 10; 
            star_coord[7] = 49; 
            star_coord[8] = 109; 
            star_coord[9] = 127;
            
            graphics.beginFill(0x003366);
            graphics.drawPath(star_commands, star_coord);
        }
    }
}

Remarque : par défaut, la méthode drawPath() utilise le type d’enroulement pair/impair. Par conséquent, le centre de l’étoile n’est pas rempli. Pour le remplir, spécifiez le type d’enroulement non nul du troisième paramètre :
 graphics.drawPath(star_commands, star_coord, GraphicsPathWinding.NON_ZERO);
 

drawRect

()méthode 
public function drawRect(x:Number, y:Number, width:Number, height:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Dessine un rectangle. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawRect(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

x:Number — Nombre indiquant la position horizontale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Nombre indiquant la position verticale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
width:Number — Largeur du rectangle (en pixels).
 
height:Number — Hauteur du rectangle (en pixels).


Valeur émise
ArgumentError — Si le paramètre width ou height n’est pas un nombre (Number.NaN).

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant indique comment dessiner des formes dans ActionScript 3.0. Exemple fourni par ActionScriptExamples.com.
var movieClip:MovieClip = new MovieClip();
movieClip.graphics.beginFill(0xFF0000);
movieClip.graphics.drawRect(0, 0, 100, 80);
movieClip.graphics.endFill();
movieClip.x = 10;
movieClip.y = 10;
addChild(movieClip);

drawRoundRect

()méthode 
public function drawRoundRect(x:Number, y:Number, width:Number, height:Number, ellipseWidth:Number, ellipseHeight:Number = NaN):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Dessine un rectangle arrondi. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawRoundRect(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

x:Number — Nombre indiquant la position horizontale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Nombre indiquant la position verticale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
width:Number — Largeur du rectangle arrondi (en pixels).
 
height:Number — Hauteur du rectangle arrondi (en pixels).
 
ellipseWidth:Number — La largeur de l’ellipse utilisée pour dessiner les coins arrondis (en pixels).
 
ellipseHeight:Number (default = NaN) — La hauteur de l’ellipse utilisée pour dessiner les coins arrondis (en pixels). Facultatif. Si aucune valeur n’est spécifiée, la valeur par défaut correspond à la valeur fournie pour le paramètre ellipseWidth.


Valeur émise
ArgumentError — Si le paramètre width, height, ellipseWidth ou ellipseHeight n’est pas un nombre (Number.NaN).

Eléments de l’API associés


Exemple
Comment utiliser cet exemple
Pour une illustration de l’utilisation de cette méthode, voir l’exemple présenté à la fin de ce cours.

drawTriangles

()méthode 
public function drawTriangles(vertices:Vector.<Number>, indices:Vector.<int> = null, uvtData:Vector.<Number> = null, culling:String = "none"):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Restitue un ensemble de triangles, généralement pour déformer les images bitmap et leur donner un aspect tridimensionnel. La méthode drawTriangles() mappe le remplissage actuel ou un remplissage sur les faces des triangles à l’aide d’un jeu de coordonnées (u,v).

Tous les types de remplissage peuvent être utilisés, mais si le remplissage possède une matrice de transformation, celle-ci est ignorée.

Un paramètre uvtData permet d’améliorer le mappage des textures lorsqu’un remplissage bitmap est utilisé.

Paramètres

vertices:Vector.<Number> — Vecteur de nombres où chaque paire de nombres est traitée comme un emplacement de coordonnées (paire x, y). Le paramètre vertices est requis.
 
indices:Vector.<int> (default = null) — Vecteur d’entiers ou d’index, où chaque groupe de trois index définit un triangle. Si le paramètre indexes est défini sur null, chaque groupe de trois sommets (six paires de x,y dans le vecteur vertices) définit un triangle. Sinon, chaque index fait référence à un sommet, ou paire de nombres dans le vecteur vertices. Par exemple indexes[1] fait référence à (vertices[2], vertices[3]). Le paramètre indexes est facultatif, mais il permet généralement de réduire le volume des données envoyées et traitées.
 
uvtData:Vector.<Number> (default = null) — Vecteur de coordonnées normalisées utilisées pour appliquer un mappage de texture. Chaque coordonnée fait référence à un point sur l’image bitmap utilisée pour le remplissage. Vous devez disposer d’une coordonnée UV ou UVT par sommet. Dans coordonnées UV, (0,0) est le coin supérieur gauche de l’image bitmap et (1,1) le coin inférieur droit.

Si la longueur de ce vecteur est le double de celle du vecteur vertices, les coordonnées normalisées sont utilisées sans correction de perspective.

Si la longueur de ce vecteur est le triple de la longueur du vecteur vertices, la troisième coordonnée est interprétée comme ’t’ (distance séparant l’oeil de la texture dans l’espace visuel). Cela permet au moteur de rendu d’appliquer correctement la perspective lors du mappage des textures en 3D.

Si le paramètre uvtData est null, les règles de remplissage normal (et tous types de remplissage) s’appliquent.

 
culling:String (default = "none") — Indique si les triangles tournés vers une direction spécifique doivent être restitués. Ce paramètre permet d’éviter de restituer les triangles que la vue en cours ne permet pas de voir. Ce paramètre peut être réglé sur toute valeur définie par la classe TriangleCulling.

Plus d’exemples

Eléments de l’API associés

endFill

()méthode 
public function endFill():void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Applique un remplissage aux lignes et aux courbes ajoutées depuis le dernier appel de la méthode beginFill(), beginGradientFill() ou beginBitmapFill(). Flash utilise le remplissage spécifié lors de l’appel précédent de la méthode beginFill(), beginGradientFill() ou beginBitmapFill(). Si la position de dessin actuelle n’est pas égale à la position précédente spécifiée dans une méthode moveTo() et si un remplissage est défini, le tracé est fermé à l’aide d’une ligne, puis rempli.

Eléments de l’API associés

lineBitmapStyle

()méthode 
public function lineBitmapStyle(bitmap:BitmapData, matrix:Matrix = null, repeat:Boolean = true, smooth:Boolean = false):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Spécifie une image bitmap à utiliser pour le trait lors du traçage des lignes.

Le style de ligne de l’image bitmap est utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineGradientStyle(), ou de nouveau la méthode lineBitmapStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineBitmapStyle() au cours du traçage pour spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineBitmapStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

bitmap:BitmapData — Bitmap à utiliser pour le trait.
 
matrix:Matrix (default = null) — Matrice de transformation optionnelle définie par la classe flash.geom.Matrix. La matrice peut être utilisée pour redimensionner ou manipuler l’image bitmap d’une manière ou d’une autre avant de l’appliquer au style de ligne.
 
repeat:Boolean (default = true) — Indique si l’image bitmap doit être répétée pour former une mosaïque.
 
smooth:Boolean (default = false) — Indique si l’image bitmap doit être lissée.

Eléments de l’API associés

lineGradientStyle

()méthode 
public function lineGradientStyle(type:String, colors:Array, alphas:Array, ratios:Array, matrix:Matrix = null, spreadMethod:String = "pad", interpolationMethod:String = "rgb", focalPointRatio:Number = 0):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9

Spécifie le dégradé à utiliser pour le trait lors du tracé des lignes.

Le style de ligne dégradée est utilisé pour tous les appels suivants aux méthodes Graphics, telles que les méthodes lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineBitmapStyle(), ou de nouveau la méthode lineGradientStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineGradientStyle() au cours du dessin pour spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineGradientStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

Les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

type:String — Valeur de la classe GradientType qui spécifie le type de dégradé à utiliser, GradientType.LINEAR ou GradientType.RADIAL.
 
colors:Array — Tableau de valeurs de couleurs RVB hexadécimales à utiliser pour le dégradé (par exemple, rouge correspond à 0xFF0000, bleu à 0x0000FF, etc.).
 
alphas:Array — Tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs disponibles sont comprises entre 0 et 1. Si la valeur est inférieure à 0, la valeur par défaut est de 0. Si la valeur est supérieure à 1, la valeur par défaut est de 1.
 
ratios:Array — Tableau de taux de distribution des couleurs ; les valeurs valides sont comprises entre 0 et 255. Cette valeur définit le pourcentage de la largeur où la couleur est échantillonnée sur 100 %. La valeur 0 représente la position de gauche dans la zone de dégradés, tandis que 255 représente la position de droite. Cette valeur représente les positions de la zone de dégradés, plutôt que l’espace de coordonnées du dégradé final, pouvant être plus large ou plus étroit que la zone de dégradés. Spécifiez une valeur pour chaque valeur dans le paramètre colors.

Par exemple, pour un dégradé linéaire qui comprend deux couleurs, bleu et vert, la figure suivante illustre l’emplacement des couleurs dans le dégradé selon les différentes valeurs du tableau ratios :

ratiosDégradé
[0, 127]dégradé linéaire du bleu au vert avec des taux de 0 et 127
[0, 255]dégradé linéaire du bleu au vert avec des taux de 0 et 255
[127, 255]dégradé linéaire du bleu au vert avec des taux de 127 et 255

Les valeurs du tableau doivent augmenter de manière séquentielle ; par exemple, [0, 63, 127, 190, 255].

 
matrix:Matrix (default = null) — Matrice de transformation définie par la classe flash.geom.Matrix. La classe flash.geom.Matrix inclut une méthode createGradientBox(), qui permet de configurer facilement la matrice en vue de son utilisation avec la méthode lineGradientStyle().
 
spreadMethod:String (default = "pad") — Valeur de la classe SpreadMethod qui spécifie la méthode d’étalement à utiliser :

dégradé linéaire avec SpreadMethod.PADdégradé linéaire avec SpreadMethod.REFLECTdégradé linéaire avec SpreadMethod.REPEAT
SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEAT

 
interpolationMethod:String (default = "rgb") — Valeur de la classe InterpolationMethod qui spécifie la valeur à utiliser. Prenons, par exemple, un dégradé linéaire simple entre deux couleurs (le paramètre spreadMethod étant réglé sur SpreadMethod.REFLECT). Les différentes méthodes d’interpolation influent sur l’aspect de la façon suivante :

dégradé linéaire avec InterpolationMethod.LINEAR_RGBdégradé linéaire avec InterpolationMethod.RGB
InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB

 
focalPointRatio:Number (default = 0) — Nombre qui contrôle l’emplacement du point focal du dégradé. La valeur 0 signifie que le point focal est au centre. La valeur 1 signifie que le point focal est au bord du cercle du dégradé. La valeur -1 signifie que le point focal est sur l’autre bord du cercle du dégradé. Toute valeur inférieure à -1 ou supérieure à 1 est arrondie à -1 ou 1. L’image suivante affiche un dégradé avec le paramètre focalPointRatio défini sur -0,75 :

dégradé linéaire avec focalPointRatio défini sur 0.75

Plus d’exemples

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

The following example draws a rectangle and a circle that use a gradient stroke from red to green to blue.

La méthode createGradientBox() de la classe Matrix est utilisée pour définir la zone de dégradé sur une largeur de 200 et une hauteur de 40. L’épaisseur de la ligne est définie sur 5 pixels. L’épaisseur du contour doit être définie pour la méthode lineGradientStyle(). Le dégradé est défini sur linéaire. Les couleurs du dégradé sont définies sur rouge, vert et bleu. La transparence (valeur alpha) des couleurs est définie sur 1 (opaque). La distribution du dégradé est régulière, avec des couleurs allant de 100 % à 0 (à gauche de la zone de dégradé), 128 (centre de la zone) et 255 (à droite de la zone). La largeur du rectangle couvre tout le spectre du dégradé, alors que le cercle en couvre 50 % depuis le centre du spectre.

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    import flash.geom.Matrix; 
    import flash.display.GradientType;
    
    public class Graphics_lineGradientStyleExample extends Sprite
    {
        public function Graphics_lineGradientStyleExample()
        {
            var myShape:Shape = new Shape();
            var gradientBoxMatrix:Matrix = new Matrix();
  
            gradientBoxMatrix.createGradientBox(200, 40, 0, 0, 0);  
            
            myShape.graphics.lineStyle(5);
  
            myShape.graphics.lineGradientStyle(GradientType.LINEAR, [0xFF0000,
            0x00FF00, 0x0000FF], [1, 1, 1], [0, 128, 255], gradientBoxMatrix);
            
            myShape.graphics.drawRect(0, 0, 200, 40);
            myShape.graphics.drawCircle(100, 120, 50);  
             
            this.addChild(myShape);
    
        }
    }
}

lineShaderStyle

()méthode 
public function lineShaderStyle(shader:Shader, matrix:Matrix = null):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 10, AIR 1.5

Spécifie un shader à utiliser pour le trait lors du traçage des lignes.

Le style de ligne du shader est utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineGradientStyle(), ou de nouveau la méthode lineBitmapStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineShaderStyle() au cours du tracé afin de spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineShaderStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

shader:Shader — Shader à utiliser pour le trait.
 
matrix:Matrix (default = null) — Matrice de transformation optionnelle définie par la classe flash.geom.Matrix. La matrice peut être utilisée pour redimensionner ou manipuler l’image bitmap d’une manière ou d’une autre avant de l’appliquer au style de ligne.

Eléments de l’API associés

lineStyle

()méthode 
public function lineStyle(thickness:Number = NaN, color:uint = 0, alpha:Number = 1.0, pixelHinting:Boolean = false, scaleMode:String = "normal", caps:String = null, joints:String = null, miterLimit:Number = 3):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie le style de ligne utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de trait demeure en vigueur jusqu’à l’appel de la méthode lineGradientStyle(), lineBitmapStyle() ou lineStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineGradientStyle() au cours du dessin pour spécifier différents styles pour divers segments de ligne dans un tracé.

Remarque : les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Remarque : Flash Lite 4 prend en charge uniquement les trois premiers paramètres (thickness, color et alpha).

Paramètres

thickness:Number (default = NaN) — Un entier qui indique l’épaisseur de la ligne en points ; les valeurs disponibles sont comprises entre 0 et 255. Si aucun nombre n’est spécifié, ou si le paramètre n’est pas défini, aucune ligne n’est dessinée. Si une valeur inférieure à 0 est transmise, la valeur par défaut est de 0. 0 correspond à l’épaisseur minimale et 255 à l’épaisseur maximale. Si la valeur transmise est supérieure à 255, la valeur par défaut est de 255.
 
color:uint (default = 0) — Valeur hexadécimale de la couleur de la ligne (par exemple, rouge correspond à 0xFF0000, bleu à 0x0000FF, etc.). Si aucune valeur n’est indiquée, la valeur par défaut correspond à 0x000000 (noir). Facultatif.
 
alpha:Number (default = 1.0) — Un nombre qui indique la valeur alpha de la couleur de la ligne. Les valeurs valides vont de 0 à 1. Si aucune valeur n’est indiquée, la valeur par défaut est de 1 (uni). Si la valeur est inférieure à 0, la valeur par défaut est de 0. Si la valeur est supérieure à 1, la valeur par défaut est de 1.
 
pixelHinting:Boolean (default = false) — (Non pris en charge dans Flash Lite 4) Valeur booléenne qui indique si des index supplémentaires de lissage des pixels doivent être ajoutés. Cette valeur affecte à la fois la position des ancres de courbe et la taille du trait. Avec pixelHinting réglé sur true, les largeurs de lignes sont réglées sur des largeurs de pixels entières . Si pixelHinting est défini sur false, les courbes et les lignes droites risquent de ne pas être continues. Les exemples ci-dessous illustrent comment Flash Player ou Adobe AIR effectue le rendu de deux rectangles arrondis identiques à une exception près : le réglage du paramètre pixelHinting utilisé par la méthode lineStyle() (les images sont mises à l’échelle 200 %, pour mettre en évidence la différence) :

pixelHinting false et pixelHinting true

Si vous ne spécifiez pas de valeur, la ligne n’utilise pas les index de lissage des pixels.

 
scaleMode:String (default = "normal") — (Non pris en charge dans Flash Lite 4) Valeur de la classe LineScaleMode qui spécifie le mode de mise à l’échelle à utiliser :
  • LineScaleMode.NORMAL — Redimensionne toujours l’épaisseur du trait si l’objet est redimensionné (valeur par défaut).
  • LineScaleMode.NONE — Ne redimensionne jamais l’épaisseur du trait.
  • LineScaleMode.VERTICAL — N’ajuste pas l’épaisseur du trait si l’objet est redimensionné verticalement uniquement. Considérons par exemple les cercles illustrés ci-dessous, dessinés dans un trait d’un pixel, et pour lesquels le paramètre scaleMode est défini sur LineScaleMode.VERTICAL. Le cercle de gauche est redimensionné verticalement uniquement, tandis que le cercle de droite est redimensionné à la verticale et à l’horizontale :

    Un cercle redimensionné verticalement, et un cercle redimensionné verticalement et horizontalement.

  • LineScaleMode.HORIZONTAL — N’ajuste pas l’épaisseur du trait si l’objet est redimensionné horizontalement uniquement. Considérons par exemple les cercles illustrés ci-dessous, dessinés dans un trait d’un pixel, et pour lesquels le paramètre scaleMode est défini sur LineScaleMode.HORIZONTAL. Le cercle de gauche est redimensionné horizontalement uniquement, tandis que le cercle de droite est redimensionné à la verticale et à l’horizontale :

    Un cercle redimensionné horizontalement, et un cercle redimensionné verticalement et horizontalement.

 
caps:String (default = null) — (Non pris en charge dans Flash Lite 4) Valeur de la classe CapsStyle qui spécifie le type d’extrémité au bout des lignes. Les valeurs possibles sont les suivantes : CapsStyle.NONE, CapsStyle.ROUND et CapsStyle.SQUARE. En l’absence de valeur, Flash utilise des extrémités rondes.

Par exemple, l’illustration suivante présente les différents réglages capsStyle. Pour chaque paramètre, l’illustration présente une ligne bleue dont l’épaisseur est de 30 (pour laquelle capsStyle s’applique), et une ligne noire superposée dont l’épaisseur est de 1 (pour laquelle aucun capsStyle ne s’applique) :

NONE, ROUND et SQUARE

 
joints:String (default = null) — (Non pris en charge dans Flash Lite 4) Valeur de la classe JointStyle qui spécifie le type d’apparence de liaison utilisé dans les angles. Les valeurs possibles sont les suivantes : JointStyle.BEVEL, JointStyle.MITER et JointStyle.ROUND. En l’absence de valeurs, Flash utilise des liaisons rondes.

Par exemple, l’illustration suivante présente les différents réglages capsStyle. Pour chaque paramètre, l’illustration présente une ligne bleue en angle dont l’épaisseur est de 30 (pour laquelle jointStyle s’applique), et une ligne noire en angle superposée dont l’épaisseur est de 1 (pour laquelle aucun jointStyle ne s’applique) :

MITER, ROUND et BEVEL

Remarque : pour les paramètres joints définis sur JointStyle.MITER, vous pouvez utiliser le paramètre miterLimit pour limiter la longueur de la pointe.

 
miterLimit:Number (default = 3) — (Non pris en charge dans Flash Lite 4) Nombre qui indique la limite à laquelle une pointe est coupée. Les valeurs disponibles sont comprises entre 1 et 255 (et les valeurs qui excèdent cette plage sont arrondies à 1 ou 255). Cette valeur n’est utilisée que si jointStyle est défini sur "miter". La valeur miterLimit représente la longueur maximale d’une pointe au-delà du point où les lignes se rencontrent pour former une liaison. La valeur exprime un facteur du paramètre thickness de la ligne. Par exemple, avec un facteur miterLimit de 2,5 et une valeur de thickness de 10 pixels, la pointe est coupée à 25 pixels.

Par exemple, les lignes d’angle suivantes dessinent un objet avec un paramètre thickness d’une valeur de 20, mais un paramètre miterLimit défini sur 1, 2 et 4. Les lignes de référence noires sont surimposées et indiquent les points de rencontre des pointes :

lignes avec miterLimit défini sur 1, 2 et 4

Notez qu’une valeur miterLimit donnée possède un angle maximal spécifique pour lequel la pointe est coupée. Vous trouverez quelques exemples dans le tableau suivant :

Valeur miterLimit :Les angles inférieurs aux valeurs indiquées sont coupés :
1,41490 degrés
260 degrés
430 degrés
815 degrés

Eléments de l’API associés


Exemple
Comment utiliser cet exemple
Consultez l’exemple de la méthode lineTo() ou moveTo() pour voir des illustrations de l’utilisation de la méthode getStyle().

lineTo

()méthode 
public function lineTo(x:Number, y:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Trace une ligne en utilisant le style de trait actuel à partir de la position de dessin actuelle jusqu’à (x, y) ; la position de dessin actuelle est ensuite réglée sur (x, y). Si l’objet d’affichage dans lequel vous effectuez le traçage possède un contenu créé à l’aide des outils de dessin Flash, les appels de la méthode lineTo() sont tracés sous le contenu. Si vous appelez lineTo() avant d’appeler la méthode moveTo(), la position de dessin par défaut prend la valeur (0, 0). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

Paramètres

x:Number — Nombre indiquant la position horizontale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Nombre indiquant la position verticale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant trace un trapèze via la méthode lineTo(), en commençant aux pixels (100, 100).

L’épaisseur des lignes est définie sur 10 pixels, la couleur est dorée et opaque, les extrémités des lignes sont définies sur aucun (car toutes les lignes se rejoignent) et la jonction entre les lignes est définie sur MITER avec une limite de pointe définie sur 10, pour obtenir des angles pointus.

package {
    import flash.display.Sprite;
    import flash.display.LineScaleMode;
    import flash.display.CapsStyle;
    import flash.display.JointStyle;
    import flash.display.Shape;


    public class Graphics_lineToExample extends Sprite {

        public function Graphics_lineToExample() {

            var trapezoid:Shape = new Shape();    

            trapezoid.graphics.lineStyle(10, 0xFFD700, 1, false, LineScaleMode.VERTICAL,
                               CapsStyle.NONE, JointStyle.MITER, 10);

            trapezoid.graphics.moveTo(100, 100);
 
            trapezoid.graphics.lineTo(120, 50);
            trapezoid.graphics.lineTo(200, 50);
            trapezoid.graphics.lineTo(220, 100);
            trapezoid.graphics.lineTo(100, 100); 

            this.addChild(trapezoid);
        }
    }
}

moveTo

()méthode 
public function moveTo(x:Number, y:Number):void

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: AIR 1.0, Flash Player 9, Flash Lite 4

Déplace la position de dessin actuelle vers (x, y). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

Paramètres

x:Number — Nombre indiquant la position horizontale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).
 
y:Number — Nombre indiquant la position verticale par rapport au point d’alignement de l’objet d’affichage parent (en pixels).


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant trace une ligne pointillée de trois pixels d’épaisseur à l’aide des méthodes moveTo() et lineTo().

Via la méthode lineStyle(), l’épaisseur de la ligne est définie sur 3 pixels. Elle est également définie pour ne pas changer d’échelle. La couleur est définie sur le rouge avec 25 pour cent d’opacité. La propriété CapsStyle est définie sur carré (le rond est défini par défaut).

Graphics_moveToExample étant une occurrence de la classe Sprite, elle a accès à toutes les méthodes de la classe Graphics. Les méthodes de la classe Graphics ne peuvent pas être utilisées pour dessiner directement sur l’objet Sprite Graphic_moveToExample. Toutefois, le fait de ne pas placer l’objet de traçage du vecteur dans une forme limite les possibilités de gestion, de déplacement et de modification.

package {
    import flash.display.Sprite;
    import flash.display.CapsStyle;
    import flash.display.LineScaleMode;

    public class Graphics_moveToExample extends Sprite
    {
        public function Graphics_moveToExample() {
            
            graphics.lineStyle(3, 0x990000, 0.25, false, 
                            LineScaleMode.NONE, CapsStyle.SQUARE);

            graphics.moveTo(10, 20);
            graphics.lineTo(20, 20);
            graphics.moveTo(30, 20);
            graphics.lineTo(50, 20);
            graphics.moveTo(60, 20);
            graphics.lineTo(80, 20);
            graphics.moveTo(90, 20);
            graphics.lineTo(110, 20);            
            graphics.moveTo(120, 20);
            graphics.lineTo(130, 20);           
        }
    }
}

readGraphicsData

()méthode 
public function readGraphicsData(recurse:Boolean = true):Vector.<IGraphicsData>

Version du langage: ActionScript 3.0
Versions du moteur d’exécution: Flash Player 11.6, AIR 3.6

Interroge un objet Sprite ou Shape (et éventuellement ses enfants) sur son contenu graphique vectoriel. Le résultat est un vecteur d’objets IGraphicsData. Des transformations sont appliquées à l’objet d’affichage avant la requête, afin que tous les chemins renvoyés se trouvent dans le même espace de coordonnées. Les coordonnées dans les données du jeu de résultats sont relatives à la scène, pas à l’objet d’affichage échantillonné.

Le résultat inclut les types d’objets, avec les limitations spécifiées :

  • GraphicsSolidFill
  • GraphicsGradientFill
    • Toutes les propriétés du remplissage en dégradé sont renvoyées par readGraphicsData().
    • La matrice renvoyée est proche de la matrice d’entrée, mais pas exactement identique.
  • GraphicsEndFill
  • GraphicsBitmapFill
    • La matrice renvoyée est proche de la matrice d’entrée, mais pas exactement identique.
    • repeat a toujours la valeur true.
    • smooth a toujours la valeur false.
  • GraphicsStroke
    • thickness est pris en charge.
    • fill prend en charge GraphicsSolidFill, GraphicsGradientFill et GraphicsBitmapFill comme décrit plus haut.
    • Toutes les autres propriétés ont des valeurs par défaut.
  • GraphicsPath
    • Les seules commandes prises en charge sont MOVE_TO, CURVE_TO et LINE_TO.

Les transformations et éléments visuels suivants ne peuvent pas être représentés et ne sont pas inclus dans le résultat :

  • Masques
  • Texte, à une exception : le texte statique défini avec type d’anticrènelage « Anticrènelage pour l’animation » est rendu comme des formes vectorielles et est donc inclus dans le résultat
  • Remplissages de shader
  • Modes de fusion
  • Mise à l’échelle à 9 découpes
  • Triangles (créés à l’aide de la méthode drawTriangles())
  • Arrière-plan opaque
  • Paramètres de scrollrect
  • Transformations 2.5D
  • Objets non visibles (dont la propriété visible est définie sur false)

Paramètres

recurse:Boolean (default = true) — si l’exécution doit également interroger les objets enfants de l’objet d’affichage en cours. L’exécution d’une requête récursive peut prendre plus de temps et de mémoire. Les résultats sont renvoyés dans un jeu de résultats aplati

Valeur renvoyée
Vector.<IGraphicsData> — Vecteur d’objets IGraphicsData représentant le contenu graphique vectoriel de l’objet d’affichage associé

Eléments de l’API associés


Exemple  ( Comment utiliser cet exemple )

L’exemple suivant utilise la méthode readGraphicsData() pour extraire le contenu des graphiques vectoriels d’un objet d’affichage. Il redessine ensuite ce contenu dans un autre objet sur la scène lorsque l’utilisateur clique sur la scène.

Notez que, bien que le contenu vectoriel d’origine soit dessiné à l’aide de la méthode drawGraphicsData(), les objets de données vectorielles extraits par la méthode readGraphicsData() ne correspondent pas exactement à ceux transmis à la méthode drawGraphicsData(). Par exemple, les données de résultat incluent les commandes GraphicsSolidFill et GraphicsEndFill, toutes deux impliquées, mais absentes des données graphiques d’origine.

package
{
    import flash.display.GraphicsPathCommand;
    import flash.display.IGraphicsData;
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    
    public class ReadGraphicsDataExample extends Sprite
    {
        private var original:Shape;
        private var copy:Shape;
        
        public function ReadGraphicsDataExample()
        {
            original = new Shape();
            original.x = 50;
            original.y = 100;
            addChild(original);
            
            drawSquare();
            
            copy = new Shape();
            copy.x = 250;
            copy.y = 100;
            addChild(copy);
            
            stage.addEventListener(MouseEvent.CLICK, drawCopyOnClick);
        }
        
        private function drawCopyOnClick(event:MouseEvent):void
        {
            // reset
            copy.graphics.clear();
            
            // Sample the vector data. Move the original to 0,0
            // before sampling so that the coordinates match the 
            // relative coordinates of the original.
            var xPos:Number = original.x;
            var yPos:Number = original.y;
            original.x = 0;
            original.y = 0;
            var result:Vector.<IGraphicsData> = original.graphics.readGraphicsData(false);
            original.x = xPos;
            original.y = yPos;
            
            // re-draw
            copy.graphics.drawGraphicsData(result);
        }
        
        private function drawSquare():void
        {
            var squareCommands:Vector.<int> = new Vector.<int>(5, true);
            
            squareCommands[0] = GraphicsPathCommand.MOVE_TO;
            squareCommands[1] = GraphicsPathCommand.LINE_TO;
            squareCommands[2] = GraphicsPathCommand.LINE_TO;
            squareCommands[3] = GraphicsPathCommand.LINE_TO;
            
            var squareCoordinates:Vector.<Number> = new Vector.<Number>(8, true);
            squareCoordinates[0] = 0;
            squareCoordinates[1] = 0; 
            squareCoordinates[2] = 50; 
            squareCoordinates[3] = 0; 
            squareCoordinates[4] = 50; 
            squareCoordinates[5] = 50; 
            squareCoordinates[6] = 0; 
            squareCoordinates[7] = 50; 
            
            original.graphics.beginFill(0x003366);
            original.graphics.drawPath(squareCommands, squareCoordinates);
        }
    }
}
GraphicsExample.as

L’exemple suivant utilise la classe GraphicsExample pour dessiner un cercle, un rectangle arrondi et un carré. Cette tâche s’accomplit de la façon suivante :
  1. Elle déclare la propriété size qui servira par la suite à déterminer la taille de chaque forme.
  2. Elle déclare les propriétés qui définissent la couleur de fond sur orange, la couleur de bordure sur gris foncé, la taille de la bordure sur 0 pixel, le rayon de l’angle sur 9 pixels et définit l’espace entre le bord de la scène et les autres objets sur 5 pixels.
  3. Elle utilise les propriétés déclarées au cours des étapes précédentes, ainsi que les méthodes intégrées de la classe Graphics pour dessiner le cercle, le rectangle arrondi et le carré aux coordonnées x = 0, y = 0.
  4. Elle redessine les formes situées le long de la partie supérieure de la scène, en commençant par x = 5, y = 5, avec un espacement de 5 pixels entre les formes.
package {
    import flash.display.DisplayObject;
    import flash.display.Graphics;
    import flash.display.Shape;
    import flash.display.Sprite;

    public class GraphicsExample extends Sprite {
        private var size:uint         = 80;
        private var bgColor:uint      = 0xFFCC00;
        private var borderColor:uint  = 0x666666;
        private var borderSize:uint   = 0;
        private var cornerRadius:uint = 9;
        private var gutter:uint       = 5;

        public function GraphicsExample() {
            doDrawCircle();
            doDrawRoundRect();
            doDrawRect();
            refreshLayout();
        }

        private function refreshLayout():void {
            var ln:uint = numChildren;
            var child:DisplayObject;
            var lastChild:DisplayObject = getChildAt(0);
            lastChild.x = gutter;
            lastChild.y = gutter;
            for (var i:uint = 1; i < ln; i++) {
                child = getChildAt(i);
                child.x = gutter + lastChild.x + lastChild.width;
                child.y = gutter;
                lastChild = child;
            }
        }

        private function doDrawCircle():void {
            var child:Shape = new Shape();
            var halfSize:uint = Math.round(size / 2);
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawCircle(halfSize, halfSize, halfSize);
            child.graphics.endFill();
            addChild(child);
        }

        private function doDrawRoundRect():void {
            var child:Shape = new Shape();
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawRoundRect(0, 0, size, size, cornerRadius);
            child.graphics.endFill();
            addChild(child);
        }

        private function doDrawRect():void {
            var child:Shape = new Shape();
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawRect(0, 0, size, size);
            child.graphics.endFill();
            addChild(child);
        }
    }
}




[ X ]Pourquoi existe-t-il du contenu en anglais ?
Certaines parties du Guide de référence ActionScript 3.0 sont en anglais

Tout le contenu du Guide de référence ActionScript 3.0 n’a pas été traduit dans toutes les langues. Si un élément de langage n’est pas traduit, il s’affiche en anglais. Par exemple, la classe ga.controls.HelpBox n’est traduite dans aucune langue. Ainsi, dans la version française du guide de référence, la classe ga.controls.HelpBox apparaît en anglais.