|By Marco Casario||
|April 17, 2009 12:15 PM EDT||
Many applications offer context menus associated with the application’s icon. On Windows systems, these menus are located in the system tray. If you’re working on a Mac OS X system, you’ll find these menus in the dock bar. Generally, these menus have shortcuts for the most common functions of the application you’re using. These menus might also contain commands that must be accessible even when the application is minimized or hidden by the desktop.
The AIR runtime allows you to manage and interact with the system tray and dock bar icons of your application. You can define context menus for them. On Microsoft Windows systems, the icons in the system tray don’t have any default context menus, so unless you have a specially prepared menu to display, it won’t provide a context menu. Mac OS X systems, on the other hand, have a default menu for dock bar icons. The menus you create will be added to the default menu provided by the operating system. You can’t modify or remove the default menus provided by the system for dock bar icons.
The application you will create in the next section will run on both Windows and Mac OS X.
Assigning a menu to an application icon
Start by opening the ch06p04.fla file in Flash CS4. The project, like the previous ones, only has an output TextArea. This TextArea will display the messages regarding the status of your application.
The project, as shown in Figure 6-13, displays an icon in the system tray or dock bar of the local system, which is why a symbol has been prepared in the library. The symbol is a movie clip: Application Icon, which represents the way you want to show the application icon. In the Symbol Properties panel, shown in Figure 6-14, the class name of the symbol has been specified: ApplicationIcon . This class name allows you to instantiate the symbol in the library via ActionScript.
You access the document class of the Flash project by clicking the Edit class definition icon on the Document Properties panel. Like for the other projects in this chapter, the Flash project has been set up to not declare the variables automatically for the elements on the stage. You’ll have to specify them yourself in the class associated with the project.
The class starts by declaring the namespace and the dependence on external classes, as shown here:
public class Ch06p04 extends MovieClip
Then you declare two class properties: one that refers to the component of the TextArea class on the stage of the project, and one to contain the native menu that the application will use:
// onstage components
public var output:TextArea;
// class properties
private var menuRoot:NativeMenu;
Next, the constructor method of the class will call the initialization of the native menu. It will check which options are supported by the local operating system. This method will also assign the menu to the menu bar of the application or window. Finally, it will assign the menu to the icon in the system tray or to the icon in the dock bar, depending on which one is available.
public function Ch06p04()
You call the createNativeMenu() function to instantiate and populate the menu that will be used for the application as well as the application’s icon. Here’s the code:
// generate native menu to use
Next, you check if the operating system supports application-level or window- level menus. After that, you assign the menu to the correct property on the basis of the functions of the operating system. This code accomplishes these tasks:
// assign to application menu if we are on Mac OS X
if ( NativeApplication.supportsMenu )
NativeApplication.nativeApplication.menu = menuRoot;
// assign to window menu if we are on Microsoft Windows
if ( NativeWindow.supportsMenu )
stage.nativeWindow.menu = menuRoot; }
Finally, you call the initIcon() method , which instantiates the ApplicationIcon symbol and uses its graphical representation as the application icon:
To instantiate and populate the native menu, you use the createNativeMenu() method , which assigns an instance of the NativeMenu class to the menuRoot class property. Then you add a submenu to the menu using the addItem() function of the NativeMenu class:
// create a complete native menu
private function createNativeMenu():void
// instantiate main menu object
menuRoot = new NativeMenu();
// append subMenus to menu root
menuRoot.addItem( createFirstSubMenu() );
The submenu is created and returned by the createFirstSubMenu() function , as shown here:
private function createFirstSubMenu():NativeMenuItem
Next, you create an instance of the NativeMenuItem class with a label of App settings. This object will be the element of the menu returned by the function. Then you assign an instance of the NativeMenu class to the submenu property of the element, so as to populate its list of items.
// create submenu
var subMenu:NativeMenuItem = new NativeMenuItem( "App settings" );
// initialize child container
subMenu.submenu = new NativeMenu();
You’ll add three methods to the menu, which will allow you to do the following:
Access the description of the application
Minimize the active window
Close the application
Each menu item is registered to an event listener method for the selection event, as shown here:
// create first child, register event listener for
// selection event and assign to submenu
var aboutCommand:NativeMenuItem = new NativeMenuItem( "About.." );
aboutCommand.addEventListener( Event.SELECT, getInformation );
subMenu.submenu.addItem( aboutCommand );
// create second child, register event listener for
// selection event and assign to submenu
var minimizeCommand:NativeMenuItem =
new NativeMenuItem( "Minimize" );
subMenu.submenu.addItem( minimizeCommand );
// create third child, register event listener for
// selection event and assign to submenu
var closeCommand:NativeMenuItem = new NativeMenuItem( "Close" );
closeCommand.addEventListener( Event.SELECT, closeApplication );
subMenu.submenu.addItem( closeCommand );
The event listener functions for the three items on the native menu are the following, and have already been explained in detail in the previous exercise regarding application menus:
// get application description
private function getInformation( evt : Event ):void
// access to application XML descriptor
var appDescriptor:XML =
// retrieve XML descriptor namespace
var nsDeclaration:Namespace = appDescriptor.namespace();
// read description node from XML
var informationText:String = String( appDescriptor.nsDeclaration::description[ 0 ] );
// write into textarea 'output' description contents
output.appendText( "Adobe Air, test application for "
+ "menus functionalities." + File.lineEnding );
output.appendText( informationText + File.lineEnding );
// close application
private function closeApplication( e : Event ):void
// minimize application
private function minimizeApplication( e : Event ):void
Preparing the application icon
Now all you have to do is correctly prepare the application icon. This is the task of the following initIcon() method , which is called at the end of the class constructor method:
// set up application icons
private function initIcon():void
First, you have to obtain an object of the BitmapData class to use as a graphical representation of the application icon. To do so, you have to instantiate the ApplicationIcon symbol in the ch06p04.fla project library .
Then create a local icon property, to which you assign an instance of the ApplicationIcon symbol. The local icon property is declared as a MovieClip, not an ApplicationIcon. This is possible because the ApplicationIcon symbol extends the MovieClip class , so it’s correct to say it’s a MovieClip. Inheritance is a fundamental concept for object- oriented programming languages like ActionScript 3.
// instanstiate icon symbol available in proj library
var icon:MovieClip = new ApplicationIcon();
Creating an object for raster representation
Now that you’ve instantiated the ApplicationIcon symbol, you have to create an object to be its raster representation. Begin by creating a BitmapData object . You specify the dimensions of its canvas as the dimensions of the icon instance you’ve just created. Then you draw the instance of the icon in the raster object using the draw() function of the BitmapData class. The draw() function allows you to draw any object that implements the IbitmapDrawable interface on the canvas of a BitmapData object. You can use this function to draw any object that implements the interface on the canvas of an object.
In ActionScript, this interface is implemented by the DisplayObject class and the Bitmap class . The following code accomplishes these tasks:
// access and save bitmapdata of icon
var iconImg:BitmapData = new BitmapData( icon.width, icon.height );
iconImg.draw( icon );
Next, you assign the raster representation of the icon for the application to the bitmaps property of the icon object of your AIR application. The bitmaps property is an array of raster representations of icons provided by an AIR application.
The runtime will use a representation with dimensions as similar as possible to the ones you’ve chosen (but exactly how similar depends on the local operating system and its graphical settings). The definition of the list of available icons for the application doesn’t depend on the local system, and you
always proceed as follows:
// define application icon
NativeApplication.nativeApplication.icon.bitmaps = [ iconImg ];
Using the correct class type for an application icon
According to the local operating system, the icon property of the nativeApplication object of the NativeApplication class can refer to instances of various classes. On Microsoft Windows systems, the icon represents an instance of the SystemTrayIcon class .
On Mac OS X systems, the icon represents an instance of the DockIcon class . You can check which type of icon is supported by checking the Boolean supportsDockIcon and supportsSystemTrayIcon properties of the NativeApplication class , which let’s you know if the system supports dock icons or system tray icons, respectively.
Here’s an example of the NativeApplication class :
if ( NativeApplication.supportsDockIcon )
If the system supports DockIcon icons , you simply assign the native menu to the menu property of the icon object. The menu will be added on the one that is natively provided by the operating system. Here’s an example of the DockIcon icons:
// assign dock icon custom menu
DockIcon( NativeApplication.nativeApplication.icon ).menu = menuRoot;
}else if ( NativeApplication.supportsSystemTrayIcon )
If, on the other hand, the system supports SystemTrayIcon icons , you also define a string of text to be used as the icon’s tooltip. SystemTrayIcon icons don’t have a menu from the operating system—just the one you provided them. DockIcon icons don’t support tooltips.
Here’s an example of a SystemTrayIcon icon:
SystemTrayIcon( NativeApplication.nativeApplication.icon ).menu
// tooltip for tray icon, available only on Windows
SystemTrayIcon( NativeApplication.nativeApplication.icon ).tooltip = "Application settings";
Go back to the Flash ch06p04.fla project to execute the application and see the results of your work (Control > Test Movie). You can see the application icon with its activated context menu in Figures 6- 15 and 6- 16. The application will work both on operating systems that support SystemTrayIcon icons (Microsoft Windows) and systems that support DockIcon icons (Mac OS X).
- Where Are RIA Technologies Headed in 2008?
- The Next Programming Models, RIAs and Composite Applications
- AJAX World RIA Conference & Expo Kicks Off in New York City
- Constructing an Application with Flash Forms from the Ground Up
- Building a Zip Code Proximity Search with ColdFusion
- Personal Branding Checklist
- CFEclipse: The Developer's IDE, Eclipse For ColdFusion
- Has the Technology Bounceback Begun?
- i-Technology Viewpoint: We Need Not More Frameworks, But Better Programmers
- Cloud People: A Who's Who of Cloud Computing
- Adobe Flex 2: Advanced DataGrid
- Web Services Using ColdFusion and Apache CXF