Developing Flex Components and Themes in Flash Authoring
Trademarks ActiveEdit, ActiveTest, Add Life to the Web, Afterburner, Aftershock, Andromedia, Allaire, Animation PowerPack, Aria, Attain, Authorware, Authorware Star, Backstage, Blue Sky Software, Blue Sky, Breeze, Bright Tiger, Captivate, Clustercats, ColdFusion, Contents Tab Composer, Contribute, Design In Motion, Director, Dream Templates, Dreamweaver, Drumbeat 2000, EDJE, EJIPT, Extreme 3D, Fireworks, Flash, FlashHelp, Flash Lite, FlashPaper, Flex, Flex Builder, Fontographer, FreeHand, Generator, Help To
CONTENTS CHAPTER 1: Working with Flash MX 2004 .............................. 5 About creating components. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Working in the Flash environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Working with component symbols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Exporting components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Contents
CHAPTER 1 Working with Flash MX 2004 This chapter describes how to set up and work in the Macromedia Flash environment when creating components for Macromedia Flex. It helps familiarize you with setting the classpath in Flash, working with symbols, and exporting component SWC files. If you are an experienced Flash developer, you may be able to skip this chapter.
• Create components that feature complex user interaction, such as the Data Grid. You can make the component respond to different user input, such as adding keyboard event listeners. • Take advantage of the Flash tools, such as font and drawing tools, to create complex graphics. Flash comes with a rich set of tools to edit graphics, sounds, and video when building a new component.
About component types Flex uses the following types of components: UI controls UI controls are visual components that represent discrete elements of a user interface (Checkbox, ComboBox, TextInput components, and so on) and are the interface between application data and the user. Containers Containers are shells for different types of content. For example, Panel is a container. The mx.containers.Container class is the base class for containers.
Symbols and MovieClips In Flash, most assets are also known as symbols, and each symbol must have a unique name. You can store symbols anywhere in the FLA file, because Flex accesses the assets by the symbol name rather than by the Timeline or Stage. A symbol is a graphic, button, or movie clip that you create in Flash MX 2004. You create the symbol only once; you can then reuse it throughout your document or in other documents.
To compile a new component’s SWC file in Flash for use in Flex, you must add the Flex SWC files and ActionScript class files to your local FLA file’s classpath. These files are included in the FlexforFlash.zip file, which is included in the Flex installation process. After you extract the contents of the FlexforFlash.zip file, you must add them to your classpath. To add Flex components to the Flash environment: 1. Close the Flash IDE if it is open. 2.
About the default classpath The default local classpath is empty. The default global classpath consists of the following paths: • . (the dot) • $(LocalData)/Classes The dot (.) indicates the current working directory. Flash searches the FLA file’s current directory for the ActionScript classes it needs. The $(LocalData)/Classes path indicates the per-user configuration directory.
To change the global classpath: 1. Select Edit > Preferences. The Preferences dialog box appears. 2. Select the ActionScript tab. 3. Click the ActionScript 2.0 Settings button. The Classpath dialog box appears. 4. Add, remove, or edit entries in the Classpath dialog box. 5. Click OK to save your changes. About importing classes Flash imports all files referenced in ActionScript classes with import statements.
Working with component symbols All components are MovieClip objects, which are a type of symbol. This section describes how to create new symbols, edit existing symbols, and convert symbols to components. Adding new symbols To create a new component, you must insert a new symbol into a new FLA file. You then convert the symbol to a component so that you can link the component to a class file. To add a new component symbol: 1. In Flash, create a blank Flash document. 2. Select Insert > New Symbol.
Editing symbols Each symbol has its own Timeline. You can add frames, keyframes, and layers to a symbol’s Timeline, just as you can to the main Timeline. On these layers and in these frames you store the graphical assets for the symbol. To edit the symbol’s linkage information: • Right-click the symbol in the Flash Library, and select Linkage. When creating components, you often start with a single symbol.
To edit symbol layers: 1. Enter Edit Symbols mode. 2. Rename an empty layer, or create a layer called main. You can use any name for the main layer; however, this document refers to this layer as the main layer. 3. In the first frame of the main layer, add a stop() action in the Actions panel, as the following figure shows: Do not add any graphical assets to this layer. 4. Rename an empty layer, or create a layer called assets.
Adding dependent components You can create new components based on existing Flex components, such as Button, CheckBox, UIObject, and UIComponent. In many cases your new component combines the functionality and symbols of existing visual Flex components. You must add the component symbols (or compiled clips) of the components on which your new component depends to the component FLA file’s Library.
You must create the class file before turning the symbol into a component. If Flash does not convert your symbol into a component, it most likely cannot find the ActionScript class. Another possibility is that the class file is not in the Flash classpath. To convert a symbol into a component: 1. Create an ActionScript class file and save it with an .as filename extension.
About component files When you create a new component with Flash MX 2004, you have a minimum of four files, as follows: *.fla file The Flash source file that contains the symbols and skins used by the component. *.as file The ActionScript source class file that defines the methods and properties of the component. *.swc file The compiled component file used by Flex. *.mxml file The Flex application file from which you invoke the component. You must be sure to store the *.as and *.
File Description Icon (Optional) Contains the 18 x 18, 8-bit-per-pixel icon used to display a component in the authoring tool user interface(s). If you don’t supply an icon, a default icon appears (see “Adding an icon” on page 71). The icon must be a PNG file. Property inspector (Optional) Supports a custom Property inspector in the authoring tool. If omitted, the default Property inspector is displayed to the user. Flex includes a single SWC file that contains all the built-in components.
Using the SWCRepair utility If your new component extends a component that is not native to the Flash environment (but is instead in the Flex Components list), you must run the SWCRepair utility against the SWC file when you finish exporting it from Flash and before you use it in Flex. This applies mostly to containers, since they are not normally used in Flash. The SWCRepair utility updates a Flash SWC file for use in Flex; the FlexforFlash.zip file includes the SWCRepair utility.
Note: You should not store custom SWC files in the /WEB-INF/flex/frameworks directory. SWC files must be at the top level of the directory. You cannot put them in subdirectories, unless you explicitly define those subdirectories with the setting. The package information for the classes in the SWC file is internalized by the SWC file, so you are not required to mirror that package when referring to the SWC file.
If the component’s ActionScript classes are in a package, you must specify a namespace that points to that package in your MXML file, as the following example shows: For more information on using namespaces for Flex components, see Developing Flex Applications.
Importing SWC files into the Flash IDE SWC files are a convenient way to share components among Flash developers. After you create a SWC file, you can give that SWC component to anyone else with Flash and they can use your component in their applications. Flash authors can use custom SWC components as they would any other component in the Flash Library.
CHAPTER 2 Creating Basic Components in Flash MX 2004 This chapter includes a set of simple examples that illustrate the basics of component development. The first part of the chapter introduces the Green Square, Orange Circle, and Blue Button components, which illustrate simple component construction and usage. The latter part of the chapter expands on the simple components and describes how to use event handling, styling, skinning, and other techniques when creating your components.
Orange Circle Create a component that exists in a package. By developing this component, you learn how to work in a namespace that uses packaged classes. Blue Button Create a component that extends an existing visual component. These components illustrate the basic concepts of component creation. Building the components also shows you the minimum requirements for creating a custom visual component in Flash for use in Flex.
super.init(); invalidate(); // Required call so that Flex draws the component. } } 8. Return to the Flash environment. Right-click the square and select Convert to Symbol. The Convert To Symbol dialog box appears. 9. In the Convert to Symbol dialog box, set the Name, Identifier, and AS 2.0 Class fields to greensquare. To access the Identifier and AS 2.0 Class fields, you must select the Export for ActionScript check box. 10. Click OK. Flash adds the greensquare symbol to the Library as a Movie Clip.
To create the Orange Circle: 1. Set up the Flash environment by adding the Flex components and class files. For more information, see “Adding Flex classes and components to the Flash IDE” on page 8. 2. In Flash, create a new FLA file. 3. Edit the FLA file’s local classpath settings to include the following two classpath entries: ■ $(LocalData)/Flex Classes ■ . (the dot) For more information, see “Changing the Flash classpath” on page 10. 4.
13. Right-click the symbol in the Flash Library and select Export SWC File. 14. Save the new SWC file as orangecircle.swc. 15. In a text editor, create an MXML file that contains the following code: You must add a namespace declaration that includes the package whenever you access a component that uses ActionScript files in packages.
5. In the Create New Symbol dialog box, perform the following steps: a Enter BlueButton in the Name field. b Enter BlueButton in the Identifier field. c Enter BlueButton in the AS2.0 Class field. To access the Identifier and AS 2.0 Class field, you must select the Export for ActionScript check box. 6. Click OK. 7. Save the FLA file as BlueButton.fla. 8. Open a text editor and create a file called BlueButton.as. Save the ActionScript file in the same directory as the BlueButton.fla file.
14. Insert a blank keyframe in the second frame of the assets layer by selecting the frame, and then selecting Insert > Timeline > Blank Keyframe. The following figure shows the layers for the BlueButton symbol: 15. Find the Button control in the Flex Components list: If you do not see the Flex Components listed in the Components panel, see “Adding Flex classes and components to the Flash IDE” on page 8. 16. Drag the Button control from the Flex Components list onto the second frame of the assets layer.
23. Copy the SWC file that you created (BlueButton.swc) to the same directory as the MXML file. This should not be the same directory into which you saved the ActionScript and FLA file. This directory must be in the web application’s directory structure so that Flex can compile a SWF from the MXML file. 24. Request the MXML file in your browser or a stand-alone Flash Player. The blue button should appear.
Defining getters and setters The recommended way of exposing properties in your class file is with a pair of getters and setters. These functions must be public. The advantage of getters and setters is that you can calculate the return value in a single place and trigger events when the variable changes. You define getter and setter functions using the get and set method properties within a class definition block.
Add the ChangeEvent metadata keyword to the getter, and a dispatchEvent() method call inside the setter. When the property’s value is set, the component dispatches the change event. Since the getter is bound to the ChangeEvent change, the binding subsystem knows what to listen for when that property changes. At the top of the class file, you must also add the Event metadata keyword to identify change as an event that this component emits.
If your custom SWC file has properties typed Array, do not use data binding to supply initial values for array properties. For example, if your custom SWC file has a labels property that is typed Array, do not use data binding in the MXML as the following example shows: The problem is that Flex instantiates the SWC file before data binding occurs.
Because nearly all classes extend the UIObject class, the initialize event is already supported in custom components. To define a handler for it, you add the initialize property to the component’s MXML tag, and then add ActionScript code that processes the event, as the following example shows: PAGE 35]]>
To handle an event that is not supported by the current parent class, such as a click event on a UIObject, you must edit the component class file. However, to add a click event to your component, it is sometimes easier to extend the Button or SimpleButton class than it is to write the code to support a click event.
} } The following MXML file handles the click event within an block:
function init() { super.init(); tabEnabled = true; invalidate(); } function keyDown(Void):Void { var k = Key.getCode(); trace("key: " + k); dispatchEvent({type:"mykeydown", myKey:k}); } } The following MXML file handles the keyboard event that the class file emits. The MXML file inspects the event object’s myKey property to determine which key the user pressed. PAGE 38} function init() { setStyle("fontSize", 24); super.init(); invalidate(); } function measure() { _measuredPreferredWidth=500; _measuredPreferredHeight=200; } } The following MXML file instantiates the BlueButton control. All instances of this BlueButton control have a default size of 500 by 200 pixels, with a label fontSize of 24. PAGE 39setStyle("color", 0x6666CC); // Set the background and border to blue when mouse hovers over control. setStyle("themeColor", 0x6666CC); super.init(); invalidate(); } } The following MXML file instantiates the BlueButton control without overriding the default styles set in the component’s class file: PAGE 40In the component’s class file, you must also override the name of the skin. Macromedia recommends that you apply the skin to your component as a clip parameter in the constructObject2() method rather than rely on the timing of the instantiation process. This is especially true when the component creates child components that rely on the positioning of the skin. You can override some or all of the control’s skins.
5. Add a second layer called assets, and add a second blank keyframe to this layer. 6. Return to the main FLA file. 7. Insert a new symbol by selecting Insert > New Symbol. The Create New Symbol dialog box appears. This new symbol will be the new skin. 8. In the Create New Symbol dialog box, do the following: a Select the MovieClip for Behavior option (the default). b Select the Export for ActionScript check box. c Enter a symbol Name. Do not specify an AS 2.0 Class name or an Identifier for this symbol.
13. Right-click the component’s symbol in the Library and select Component Definition. In the AS 2.0 Class field, enter the class name. 14. Export the SWC file. For more information, see “Creating SWC files” on page 18. 15. Add the new component to an MXML file and request that file to see the new skin. If the skin is not positioned properly on the Stage, you can rearrange it by returning to the FLA file and editing the skin’s symbol.
The following ActionScript class file creates a component that instantiates TextArea and Button controls: // Import all necessary classes. import mx.core.UIComponent; import mx.controls.Button; import mx.controls.TextArea; [Event("click")] class CompoundComponent extends UIComponent { static var symbolName:String="CompoundComponent"; static var symbolOwner:Object = CompoundComponent; var className:String = "CompoundComponent"; function CompoundComponent() { } function init() { super.
Chapter 2: Creating Basic Components in Flash MX 2004
CHAPTER 3 Creating Advanced Components in Flash MX 2004 This chapter describes the details of creating visual, interactive components in the Macromedia Flash MX 2004 workspace for use in Macromedia Flex applications. The majority of the work is in writing the ActionScript class file, which derives from Flex existing classes, and adding your own custom functionality.
The process of creating a Flex component in Flash is different from the one for creating general-use Flash components. It is possible, and even desirable, to create components that operate in both environments; however, there are certain optimizations available to Flex applications that require that components behave in a more sophisticated manner.
Simple example of a class file The following is a simple example of a class file called MyComponent.as. If you were creating this component, you would link this file to the component in the Flash IDE. This example contains a minimal set of imports, methods, and declarations for a component that inherits from the UIObject class. //Import packages. import mx.core.UIObject; //Declare the class and extend from the parent class. class myPackage.
7. Implement the createChildren() method. 8. Implement the measure() method. 9. Implement the layoutChildren() method. 10. Implement the draw() method. 11. Add properties, methods, and metadata. The ordering of methods that you implement in this process mirrors that in the component instantiation life cycle. By understanding which methods are called and in what order, you can better understand how you write a component’s class file.
About the UIObject and UIComponent classes Components based on version 2 of the Macromedia Component Architecture descend from the UIObject class, which wraps the MovieClip class. The MovieClip class is the base class for the classes in Flash that can draw on the screen. By providing a wrapper around its methods and properties, Flex makes the UIObject syntax more intuitive and improves the conceptual management of representing graphic objects.
Accessing application scope Every class that extends the UIObject class has an application property that stores a reference to the Application object. You can use this property to access data or methods at the application level. Because the event handlers and the bindings of a component execute in the context of that component, using the Application object gives you access to the application scope.
The following example adds the symbolName, symbolOwner, and className properties to the MyButton class: class MyButton extends mx.controls.Button { static var symbolName:String = "myPackage.MyButton"; static var symbolOwner = myPackage.MyButton; var className:String = "MyButton"; ... } About the component instantiation life cycle When you instantiate a new component, Flex calls a number of methods, and those methods call other methods that you can override.
Writing the constructor Generally, component constructors should be empty so that the object can be customized with its properties interface. For example, the following code shows a constructor for MyComponent: function MyComponent() { } In this example, when a new component is instantiated, the MyComponent() constructor is called. Setting properties in the constructor can lead to overwriting default values, depending on the ordering of initialization calls.
When it instantiates the component, the Flex framework creates an initialization object ({foo: and passes it to the constructObject2() method. The constructObject2() method sets this property. "myvalue"}) Clip parameters can take any number of comma-separated arguments. Flex stores the clip parameters as an array. Every argument in the clip parameter definition must have a “:1” after it in order for Flex to let you use it.
Implementing the constructObject2() method The constructObject2() method is effectively the constructor for your class. The method calls the init() and createChildren() methods. It should apply any properties in the initObj that are needed by init() and createChildren(), and then call super.constructObject2(). UIObject.
The following table describes the arguments: Argument Type Description className Object The name of the class. instanceName String The name of the instance. depth Number The depth for the instance. initObject Object The object that contains the initialization properties.
Flex only calls the commitProperties() method after it calls the invalidateProperties() method. For example, the ViewStack container uses the commitProperties() method to maximize performance. When you set the ViewStack.selectedIndex property, the ViewStack container doesn’t update to a new page right away. Instead, it privately stores a pendingSelectedIndex property. When it is time for Flash Player to update the screen, Flex calls the commitProperties(), measure(), layoutChildren(), and draw() methods.
By default, Flex sets the values of _measuredPreferredWidth and _measuredPreferredHeight to the values of the current height and width, but you should override them. The following example of the measure() method from the Label component sets a default width and height if the label text field is empty: function measure(Void):Void { var myTF = _getTextFormat(); var txt = text; if (txt == undefined || txt.length < 2) { txt = "Wj"; } var textExt = myTF.getTextExtent2(txt); var textW = textExt.
{ mode_mc.move(layoutWidth - mode_mc.width, 0); text_mc.move(0, 0); } else { mode_mc.move(0, 0); text_mc.move(mode_mc.width, 0); } } Implementing the draw() method The draw() method displays objects on the screen. Whenever the component needs to draw an interface element, it calls a draw() method. You use the draw() method to create or modify elements that are subject-to-change. Everything is made visible in the draw() method.
To define getter and setter methods, precede the method name with get or set, followed by a space and the property name. Macromedia recommends that you use initial capital letters for the second word and each word that follows. For example: public function get initialColorStyle(): Number The variable that stores the property’s value cannot have the same name as the getter or setter. By convention, precede the name of the getter and setter variables with two underscores (__).
Metadata tags The following table describes the metadata tags that you can use in ActionScript class files: Tag Description Bindable Reveals a property in the Bindings tab of the Component inspector. For more information, see “Bindable” on page 60. ChangeEvent Identifies events that cause data binding to occur. For more information, see “ChangeEvent” on page 61. Effect Defines the valid property name for the tag’s effect. For more information, see “Effect” on page 62.
Use the Bindable metadata keyword to make properties and getter and setter functions in your ActionScript classes appear on the Bindings tab in the Component inspector. The Bindable metadata keyword has the following syntax: [Bindable[readonly|writeonly[,type="datatype"]]] The Bindable keyword must precede a property, a getter or setter function, or other metadata keyword that precedes a property or getter or setter function.
The Bindable keyword is required when you use the ChangeEvent metadata keyword. For more information, see “Bindable” on page 60. In the following example, the component generates the change event when the value of the flavorStr property changes: [ChangeEvent("change")] public var flavorStr:String; When the event specified in the metadata occurs, Flash informs whatever is bound to the property that the property has changed.
The following example identifies the myClickEvent event as an event that the component can dispatch: [Event("myClickEvent")] If you do not identify an event in the class file with the Event metadata keyword, the compiler ignores the event during compilation, and Flex ignores this event triggered by the component during runtime. The metadata for events is inherited from the parent class, however, so you do not need to tag events that are already tagged with the Event metadata keyword in the parent class.
Option Type Description environment String (Optional) Notes which inspectable properties should not be allowed (none), which are used only for Flash (Flash), and which are used only by Flex and not Flash (MXML). format String (Optional) Indicates that the property holds a value with a file path. listOffset Number (Optional) Defines the default index of a List value. Added for backward compatibility with Flash MX components.
The InspectableList metadata keyword has the following syntax: [InspectableList("attribute1"[,...])] The InspectableList keyword must immediately precede the class definition because it applies to the entire class and not individual members of the class.
Style The Style metadata keyword describes a style property allowed for the component. The Style metadata keyword has the following syntax: [Style(name=style_name[,option=value,...])] The following table describes the options for the Style metadata keyword: Option Type Description name String (Required) The name of the style. type String The type of data. format String Units of the property. inherit String Whether the property is inheriting. Valid values are yes and no.
// A setter. [Inspectable(defaultValue="default text")] function set text(t:String) Parameters can be any of the following supported types: • • • • • • • • Array Object List String Number Boolean Font Name Color Handling events The event model is a dispatcher-listener model based on the DOM Level 3 proposal for event architectures. Every component in the architecture emits events in a standard format, as defined by the convention.
The event object has an implicit property, target, that is a reference to the object that triggered the event. For more information on events, see Developing Flex Applications. Defining event handlers You define the event handler object or event handler function that listens for your component’s events in your application’s ActionScript. The following example handles the change, focusOut, and click events of the children of the component: function handleEvent(evt:Object):Void { if (evt.
invalidate() Indicates that just the visuals for the object have changed, but size and position of subobjects have not changed. This method calls the draw() method. invalidateProperties() commitProperties() Indicates that you have changed properties. This method calls the method. You should call the invalidateSize() method infrequently because it measures and redraws everything on the screen, and this can be an expensive action.
In some cases, you must call the invalidate() method after changing skin properties. This depends on where you set the skin. If you set it prior to the layoutChildren() method, the invalidate() call in that method takes care of it for you. But if you set skin properties late in the component instantiation life cycle, you might have to call the invalidate() method again to have Flash draw the new skins.
Making components accessible A growing requirement for web content is that it should be accessible to people who have disabilities. Visually impaired people can use the visual content in Flash applications by means of screen reader software, which provides an audio description of the material on the screen. When you create a component, you can include ActionScript that enables the component and a screen reader to communicate.
Adding ToolTips ToolTips appear when a user rolls the mouse over your component name or icon in the Components panel of the Flash authoring environment. To add a ToolTip to your component, use the tiptext keyword outside the class definition in the component’s ActionScript class file. You must comment out this keyword using an asterisk (*), and precede it with an at sign (@) for the compiler to properly recognize it.
• Always implement an init() method and call the super.init() method, but otherwise keep the component as lightweight as possible. • Use the invalidate() and invalidateStyle() methods to invoke the draw() method instead of calling the draw() method explicitly. Using the ModalText example The following code example implements the class definition for the ModalText component.
// in this example). super.init(); } /*** f) Implement createChildren(). ***/ // Declare two children member variables. var text_mc:TextInput; var mode_mc:SimpleButton; // Declare default skin names for the button states. // This is optional if you do not want to allow skinning. var modeUpSkinName:String = "ModalUpSkin"; var modeOverSkinName:String = "ModalOverSkin"; var modeDownSkinName:String = "ModalDownSkin"; // Note that we test for the existence of the children before creating them.
text_mc.move(0, 0); } else { mode_mc.move(0, 0); text_mc.move(mode_mc.width, 0); } } /*** i) implement draw ***/ // Set flags when things change so we only do what we have to. private var bTextChanged:Boolean = true; // Set text if it changed, and draw a border. function draw():Void { clear(); if (bTextChanged) { bTextChanged = false; text_mc.text = text; } // Draw a simple border around everything.
bTextChanged = true; invalidate(); } function get text():String { if (bTextChanged) return __text; return text_mc.text; } // Handle events that are dispatched by the children. function handleEvent(evt:Object):Void { if (evt.type == "change") { dispatchEvent({ type: "change" }); } else if (evt.type == "focusOut") { text_mc.editable = false; } else if (evt.type = "click") { text_mc.editable = !text_mc.
I get an error "xxx is not a valid attribute ..." when I try to use the component from MXML. Ensure that the attribute is spelled correctly and is marked as Inspectable in the metadata. The metadata syntax is not checked, so ensure that there are no misspellings or syntax errors. Also be sure that it is not private. For more information, see “Inspectable” on page 63. I don't get any errors, but nothing shows up. Verify that the component was instantiated.
static function bar():Number { return mx.example.A.foo(); } static var z = B.bar(); // Dependency static var ADependency = mx.example.A; } The component is instantiated properly but does not show up (#2) Verify that the _measuredPreferredWidth and _measuredPreferredHeight properties are nonzero. If they are zero, ensure that you implemented the measure() method correctly. Sometimes you have to ensure that subobjects are created in order to get the correct measurements.
INDEX A accessibility, for custom components 71 ActionScript classpath in Flash 9 writing for a new component 46, 47 applyProperties 52 AS 2.
E Edit Symbol mode 12 editing symbols, for components 13 Effect metadata keyword 60, 62 effects, custom components 62 enableAccessibility() method 71 Event metadata keyword 60, 62 events adding 67 binding properties with 31 handling 67 handling in custom components 67 metadata 68 Export in First Frame option 72 exporting custom components 16 extending classes 49 F Flash MX 2004 authoring environment, adding Flex components 8 creating symbols 12 importing classes 11 using Flex classes 8 FlexforFlash.
R redraw() method 58 resizing custom components 56 S scope, custom components 50 screen readers, accessibility in custom components 71 setStyle() method 70 setters, defining for custom components 31 skinning custom components 69 startDrag() method 49 styleDeclaration object 70 styles adding 70 for custom components 38, 70 Style metadata keyword 60 SWC files contents 18 creating 18 file format explained 17 importing into Flash 22 using in Flex 19 symbol layers, editing for a new component 13 symbol names, fo
Index
