You can call as a normal class because constructor is public.
Sequence Command is used to add multiple commands to one event type.
Flex is very mature component-based development framework that reduces the development time and gives very good results. There are plenty of advantages: Easy to learn, Flash Player available widely, Works really well with other back-end technologies (specially with java), based on components so very easy to debug and fix, also has a very good IDE etc. The disadvantages are: applications used to be slightly heavy etc. But all of them can be handled to a good extent by following up best-practices and good application architecture.
Yes.
Both are used for editing,but item renderer is used for displaying visual elements..
addEventListener (type: string, listener: function, useCapture: Boolean=false, priority:int=0, useWeakReference:Boolean=false):void
To cancel the default behaviour of the event. The methods of the Event class can be used in event listener functions to affect the behaviour of the event object. Some events have an associated default behaviour. For example, the doubleClick event has an associated default behaviour that highlights the word under the mouse pointer at the time of the event. Your event listener can cancel this behaviour by calling the preventDefault () method.
PreventDefault () method will work only if Cancellable property is true, otherwise it’s not working.
Cascading Style Sheets (CSS) are used in Flex to apply styles to visual components on the application display list. CSS is a standard for encapsulating the code that makes up the design of an Application. Given the power and maturity of CSS, most experienced Web designers/developers strive to implement as much of the design and layout properties of a Web site/application in CSS as possible. The result is much greater control and flexibility over the look and feel of the site.
Some features of CSS:
Item Edit Beginning, Item Edit Begin, Item Edit End
The measure() method sets the default component size, in pixels, and optionally sets the component's default minimum size.
This method is used for following reasons:
filterFunction: Function [read-write] : A function that the view will use to eliminate items that do not match the function criteria.
A filter function is expected to function (item: Object): Boolean When the return value is true if the specified item should remain in the view. If a filter is unsupported, flex throws as error when accessing this property. We must call refresh () method after setting the filter function property for the view to update.
Data binding is the process by which changes in one action script object are reflected in another action script object. (OR) Data binding automatically copies the value of a property of a source object to a property of a destination object when the source property changes.
Data binding requires a source property, a destination property, and a triggering event that indicates when to copy the data from the source to the destination. An object dispatches the triggering event when the source property changes
Adobe Flex provides 3 ways to specify Data binding:
String is immutable and String Buffer is mutable. String class creates new instance for any method but String Buffer updates/modifies same instance.
Graphical skinning, Programmatic Skinning and Stateful skinning:
Graphical Skins: Images that define the appearance of the skin. These images can JPEG, GIF, or PNG files, or they can be symbols embedded in SWF files. Typically you use drawing software such as Adobe Photoshop or Adobe Illustrator to create graphical skins.
Programmatic Skins: Action Script or MXML classes that define a skin. To change the appearance of controls that use programmatic skins, you edit an Action Script or MXML file. You can use a single class to define multiple skins.
Sateful Skins: A type of programmatic skin that uses view states, where each view state corresponds to a state of the component. The definition of the view state controls the look of the skin. Since you can have multiple view states in a component, you can use a single component to define multiple skins.
Cairngorm is an implementation of several design patterns that form a lightweight architectural framework. Cairngorm follows the principle of separating the view and business logic which is known as the Model-View-Controller pattern (MVC).
The Pieces of Cairngorm:
The Blaze DS uses four main configuration files namely:
Override a method of a base class in your ActionScript component. To override the method, you add a method with the same signature to your class, and prefix it with the override keyword
Array Collection, XML List Collection, Grouping Collection.
Java Adapter is used to communicate with Java and JMS adapter is used to communicate with JMS. Java adapter class allows us to invoke methods on a Java object.
Remote Object: Remote Service automatically serializes and deserializes the data between Flex client and your server side language. As a result, you can directly call methods on your Java/.Net/ColdFusion/PHP etc… objects. This service connects to an AMF (Action Message Format) Gateway. AMF protocol trfers data in a binary format, so the data can be moved across the network more quickly.
endpoint: This property is used to identify the Java web project from your flex client project.
Ex: http://localhost:8080/JavaTest/messagebroker/amf
Sateful Skins: A type of programmatic skin that uses view states, where each view state corresponds to a state of the component. The definition of the view state controls the look of the skin. Since you can have multiple view states in a component, you can use a single component to define multiple skins.
No. Method overloading is not supported in Action Script3.0.
Making use of the already created class functionality or behaviour by instantiating the class and calling the required methods.
<mx:DataGridColumn headerText="ADD" dataField="add" itemRenderer="mx.controls.Button"/>
<itemrendere>
</itemRenderer>
A set of methods the framework calls to instantiate, control and destroy components. OR The component instantiation life cycle describes the sequence of steps that occur when you create a component object from a component class. As part of the life cycle, Flex automatically calls component methods, dispatches events, and makes the component visible.
3 Main Phases:
override protected function createChildren():void{
myLab=new Label();
myLab.text="my label";
myLab.setStyle('color',"green");
this.addChild(myLab);
}
override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void {
myLab.move(0,0);
myLab.setActualSize(100,100);
}
Sealed Class:
Dynamic Class:
The callLater () method queues an operation to be performed for the next screen refresh, rather than in the current update. Without the callLater () method, you might try to access a property of a component that is not yet available.
Syn: callLater(method:Function, args:Array):void
Ex: We have a button click event that loads data from a XML file or a webservice. That loading of data would probably have another resultHandler which will wait for the loading to finish. And meanwhile your button click handler might be doing some other things …so in these situations we can use callLater.
Actually ViewStack and ViewState are not related. View states give one way to change the look and feel of a component in response to user action. We can also use navigation container e.g. Acordion, ViewStack, Tab navigator etc. Choice of selecting navigation container or states depends upon requirement of application.
This method prevents the events that represent changes to the underlying data from being broadcasted by the view. It also prevents collection from being updated. This method is useful where multiple items in collection are being edited at once. By disabling the auto update the changes are received as a batch instead of multiple events. Also in a DataGrid this method prevents update to the collection while a specific item is selected. When item is no longer selected the DataGrid controls calls enableAutoUpdate() method.
We use this function to limit the data view in the collection to a subset of source data object. The function must take a single Object parameter, which corresponds to a collection item, and must return a Boolean value specifying whether to include the item in the view.
BlazeDS provides a set of services that lets you connect a client-side application to server-side data, and pass data among multiple clients connected to the server. BlazeDS implements real-time messaging between clients.
Blaze DS services:
HTTP Service: HTTP Service components to interact with JSP’s, Servlets and ASP Pages that are not available as Webservice or remoting services destinations.
<mx:HTTPService id=”myService” url=”http://localhost:8400/middlejava/LoginServlet” result=”resultHandler(event)” fault=faultHandler(event)” method=”Get”/>
Webservice: Webservice components let you access webservices, which are software modules with methods. Webservices methods are commonly referred to as operations. Webservice interfaces are defined by using XML. Flex application can interact with webservices that define their interfaces in a Webservices Description Language (WSDL) document, which is available as a URL. WSDL is a standard format for describing the messages that a webservice understands the format of these responses to those messages.
<mx: WebService id=”Webservice” wsdl=”http://search.yahoo.com/searchservice?wsdl” result=”resultHandler (event)” fault=faultHandler (event)” method=”Get”/>
Remote Object: Remote object components let us access the methods of server side java objects, without manually configuring the objects as webservices. We can use remote object components in MXML or ActionScript. We can use RemoteObject components with a standard alone BLAZE DS web application or macromedia ColdFusion MX from Adobe.
A cursor is a position indicator; it points to a particular item in the collection. We use view cursor to traverse items in a collection’s data view and modify the data in collection.
A view cursor includes following methods:
These tags provide information to Flex compiler regarding the usage of our component. Examples are Bindable, Event, DefaultProperty, Inspectable etc.
HTTP Channel, AMF Channel, RTMP Channel:
Target: The object that dispatched the event (doesn’t change). Target will not change.
Current Target: The object who is currently being checked for specific event listeners (changes). Current target is keep on change.
Flash is used by the designers. Flex is used by the developers. Flash uses only Flash Player API but Flex uses both Flash Player API and Flex SDK library also. like datavisualization.swc, automation.swc, rpc.swc.
Shared objects function like browser cookies. The SharedObject class to store data on the user's local hard disk and call that data during the same session or in a later session. Applications can access only their own SharedObject data and only if they are running on the same domain. The data is not sent to the server and is not accessible by other Adobe® Flex® applications running on other domains, but can be made accessible by applications from the same domain.
Public var so : SharedObject = SharedObject.getLocal("mySO");
so.data.fName = "Wisdomjobs";
To dispatch a new event from your custom component, you must do the following:
Clone method creates duplicate copy of the event class. This method is executed automatically when the event is redispatched in the event listeners.
The singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. If we create the class as a singleton then no way to create more than one instance. But, we can get that single instance in any number of classes. So all the classes will share the same properties and behaviours of that singleton object.
Steps to create a Singleton class:
Consider the MySingleTon class as a singleton class.
package {
public class MySingleTon {
// Single Instance of Our MySingleTon
private static var instance:MySingleTon;
//DEFINE YOUR VARIABLES HERE
public function MySingleTon (enforcer:SingletonEnforcer)
{
if (enforcer == null)
{
throw new Error( "You Can Only Have One MySingleTon");
}
}
// Returns the Single Instance
public static function getInstance() : MySingleTon
{
if (instance == null)
{
instance = new MySingleTon ( new SingletonEnforcer );
}
return instance;
}
}
}
// Utility Class to Deny Access to Constructor
class SingletonEnforcer {}
Exclude(and ExcludeClass) tags simply influence the set of choices that are available in Flex Builder. They don’t exclude the classes from linking, which is a general misconception. There are MXML options to say “I want to treat this symbol as exteranally defined” . Depending on how we compile our application, generally the classes that are included are those that are referenced from the root application or classes, either directly or via some other class that is referenced directly or not from the root application or classes. The -link-report mxmlc option is very useful in that it tells us
Flex is an application framework (yes it is a framework!!) that allows developers to build rich applications for desktop (using AIR), web, mobiles and tablets (iOS, android, blackberry etc). The web applications (SWF Files) run in Flash Player which is available in more than 90% computers across the world. For desktop-based applications AIR is needed. There are two main building blocks for development in Flex: ActionScript (used mainly for Logic part) and MXML (used mainly for declaration of tags and components etc).
There can be lot of syntactic or other differences between the two, but major difference is: In Flex 4 the architecture of components (most of) have got changed. These components (called Spark the older ones in Flex 3 are called Halo) have separated the role of developer and designer. Spark components have one main core component class (written in actionscript) that contains the main logical part and one Skin class that handles all the visual aspects. We can say core component is skeleton and skin is its visual appearance. For example spark button has one core Button class and one skin class for it.
4.5 and 4.6 are used for developing mobile based applications. 4.6 has few new components.
4.0: