Advanced code editing

Code templates speed-up your coding efforts by letting you auto-insert frequently used coding patterns.

Flash Builder includes a number of predefined code templates. You can also define additional code templates for commonly used code patterns. To see all the available code templates, open the Preferences dialog box, and select Flash Builder > Editors > Code Templates.

 Adobe Community Professional, Paul Robertson, blogged about using code templates.

Flash Builder provides you with an option to select and override parent class methods or implement interface methods.

Flash Builder displays code completion hints for metadata that you use in your MXML and ActionScript documents.

In an MXML document, metadata code hints are displayed within embedded <fx:Metadata> and <fx:Script> tags. In an ActionScript document, metadata code hints are also displayed for ActionScript language elements like class names, variables, getters, and setters.

The code hints are contextual to the MXML and ActionScript document, and the code in which the metadata is used. For example, when you invoke Content Assist within two blank lines of an ActionScript statement, code hints applicable to only that ActionScript statement appear. To see all the valid code hints applicable to the ActionScript or MXML document, press Control+Space multiple times to cycle through the available code hints.

Flash Builder allows you to customize the default information contained in new MXML, ActionScript, and CSS files. Examples of information you can specify include variables for specifying author and date, variables for opening and closing tags and attributes, variables for various ActionScript declarations, namespace prefixes, and just about any content you want to include in a template file. File templates are especially useful for specifying introductory comments and copyright information.

After modifying a template, you can export the template so it can be shared with other members of your team.

Use Quick Assist to generate stub code for an undefined method, variable, or class in your code. The generated stub code can be used as a placeholder for the code that you want to implement later without rendering your code incompatible. To customize the predefined stub code that Flash Builder generates, see Code templates.

To invoke Quick Assist, you can use the keyboard shortcut Control+1(Windows) or Command+1 (Mac OS).

Use Quick Assist to generate stub code in the relevant class or MXML script block by selecting any of the following actions:

Generate Method

Creates a method

For example, if you have code as follows:

private function genFunc():void 
{  
bar(); 
}

Place your cursor anywhere in the line of code containing bar(); and press Control+1. An option to create a function appears. On selecting this option, a new function is generated as follows:

private function bar():void{}

You can also generate a function for an undefined function in a referenced class. For example, if you have an undefined function "setValue()" in the referenced class "MyClass", as follows:

MyClass cls = new MyClass(); 
cls.setValue(5);

Place your cursor anywhere in the line of code containing "setValue" and press Control+1. An option to create a function appears. On selecting this option, a new function setValue(int) is generated in the referenced "MyClass" as follows:

 private function setValue(param0:int):void 
{ 
    // TODO Auto Generated method stub 
}

Generate Variable

Creates a property

For example, if you have code, where, i is an undefined variable, as follows:

public function MyClass 
{ 
        i; 
}

Place your cursor anywhere in the line of code containing i; and press Control+1. You get options to create a local variable or a field.

Selecting the option to create a local variable, creates the variable as follows:

var i:Object;

Selecting the option to create a field, creates a class-level variable as follows:

private var i:Object;

You can also generate a property for an undefined variable in a referenced class. For example, if you have an undefined variable "aValue" in the referenced class "MyClass", as follows:

MyClass cls = new MyClass(); 
cls.aValue = "str"; 

Place your cursor anywhere in the line of code containing aValue, press Control+1, and select Create Field Variable. A property aValue of type string is generated in the referenced "MyClass" as follows:

private var aValue:String;

Generate Class/Interface

Creates a class or interface

For example, if you have code, where Foo is undefined, as follows:

public function myFunction():Foo; 
    { 
    }

Place your cursor anywhere in the line of code containing Foo; and press Control+1. Options to create a class or interface named Foo appear. Select one of these options to open either the New ActionScript Class wizard or New ActionScript Interface wizard. Enter the necessary details and click Finish. After clicking Finish, a class or interface with the name Foo is created.

When you generate a new class, you can create an ActionScript class with a parametrized constructor.

For example, if you have code like the following:

Private function func(): void { 
    New NewClass("str1"); 
}

Place your cursor anywhere in the line of code containing NewClass("str1"), press Control+1, and select Create Class. An ActionScript class with a parametrized constructor is created. If you, however, specify a superclass for the ActionScript class, then a parameterized constructor is not generated.

Adobe Community Professional, Paul Robertson, blogged about using Quick Assist for external classes and interfaces.

Generate Event Handler

Generates event handler functions

For example, if you have code like the following:

public function MyClass 
    { 
        Var button:Button = new Button(); 
        button.addEventListener(DragEvent.DRAG,dragHandlerFunction); 
    }

Place your cursor anywhere in the line of code containing dragHandlerFunction, and press Control+1. Then, select the Quick Assist option to create the event handler. The event handler function is created as follows:

protected function dragHandlerFunction (event:DragEvent):void 
{ 
}

Generate Import Statement From Usage

Creates an import statement

For example, if you have code where the variable type Button is undefined, as follows:

<fx:Script> 
    <![CDATA[ 
        var btn:Button; 
    ]]> 
</fx:Script>

Place your cursor anywhere in the line of code containing var btn:Button, and press Control+1. You get an option to import Button if a class named Button is available in the project. The import statement is created as follows:

import spark.components.Button;

You can generate import statements for function arguments, function return types, and such.

Get and set accessor functions (getters and setters) let you keep class properties private to the class. They allow users of the class to access those properties as if they were accessing a class variable (rather than calling a class method).

Flash Builder can generate ActionScript get and set accessor functions for class variables. You can select a bindable property and generate get and set accessor functions for that property. You can also specify a custom event name at the time of generating code.