The Essential Guide to Flash CS4 AIR Development book is oriented to Flash developers interested in building desktop applications via Adobe AIR. You can order The Essential Guide to Flash CS4 AIR Development on Amazon or buy it on local bookstore.
Menus are an integral part of your life as a software user. You find them on the Web, in desktop applications, on your own operating system, and even on mobile devices like cell phones and personal digital assistants (PDAs) . You often don’t realize how important menus are when you use them. It’s so obvious to have them that you only realize how important they are when they aren’t available.
On the Web, you normally have menus regarding the browser, which allow you to access the content of the site you are using. You rarely have menus that give you access to the specific commands and functions of the website. However, things are changing slowly with the advent of Web 2.0 applications, and menus—not only browsing menus but those specifically related to the web application—are becoming more and more frequent.
As Flash web developers, you have the following options to create menus for your applications:
Adding items to the context menu provided by Flash Player
Creating your own menus
Both options work very well, but the option of using Flash Player’s context menu doesn’t give you much flexibility. The other option requires a substantial amount of time and effort to obtain valid results if you create the menus for your web application from scratch.
When you develop Adobe AIR applications with Flash CS4, you don’t need to worry about how to offer advanced functions with a menu. The framework itself provides various solutions to choose from according to your needs. AIR implements two new classes that aren’t available for Flash Player in a web environment in the flash.display package :
- NativeMenu
- NativeMenuItem
These classes allow you to create native system menus to use as application menus (on Mac OS X systems), window menus (on Windows systems), pop- up menus, and context menus. The native menu classes are an addition to the following classes that are already available to create personalized context menus:
- ContextMenu
- ContextMenuItem
The native menu classes provide more flexibility than the traditional classes for context menus. This chapter will provide information on the options you have to create menus for your applications. We’ll begin with a tour of the various types of menus that you can use for your AIR applications:
- Window menus (Microsoft Windows systems)
- Application menus (Mac OS X systems)
- System tray and dock icon menus
- Context menus
- Pop-up menus
Menus are hierarchical structures: they have a root, and in the case of native menus, they are represented by an instance of the NativeMenu class . A menu is a series of nodes that can be commands or, in turn, menus themselves. Any node is represented by instances of the NativeMenuItem class . When a command is selected, it generates an event, which conveys the information regarding the element of the relevant menu. This event is conveyed as an instance of the flash.events.Event class . Recall that application and window menus can’t contain commands as top- level elements.
Therefore all the instances of the NativeMenuItem class that are top- level nodes contain instances of the NativeMenu class to define the submenus.
It’s possible to associate the following types of information to each instance of the NativeMenuItem class:
- The name property : A single and unique identification that won’t be displayed
- The label property : A text label that will be displayed in the menu
- The data property : An object of any kind, containing information regarding the selected item on the menu
In addition to the selection event, the elements of the menu also generate a display event. The display event is generated a moment before a drop- down menu is rendered by Flash Player. This event allows you to update the content of the menu before it is displayed. You can register the display event both on the instance of the NativeMenu class that contains the menu and one of its items.
A good example of how to use the display event is in a menu that lists the recent web pages that the user has visited. Each time the user accesses the list, the application regenerates the list by checking which pages have been visited lately. It is also possible to use the display event to disable or hide the items on the menu when necessary. You might want to do this if the user doesn’t have the necessary privileges to access some of the functions of your application.
Creating a native menu
When you work on native menus in AIR, you always deal with instances of the NativeMenu class. To create a native menu, start up Flash CS4 and open the AIR ch06p01.fla project . The project has been set up so that it doesn’t automatically declare the variables of the elements on the screen. This option is defined by the Automatically declare stage instances check box in the Advanced ActionScript 3.0 Settings panel, which can be reached through the Publish Settings panel.
Menus are hierarchical structures: they have a root, and in the case of native menus, they are represented by an instance of the NativeMenu class . A menu is a series of nodes that can be commands or, in turn, menus themselves. Any node is represented by instances of the NativeMenuItem class . When a command is selected, it generates an event, which conveys the information regarding the element of the relevant menu. This event is conveyed as an instance of the flash.events.Event class. Recall that application and window menus can’t contain commands as top- level elements.
Therefore all the instances of the NativeMenuItem class that are top- level nodes contain instances of the NativeMenu class to define the submenus.
It’s possible to associate the following types of information to each instance of the NativeMenuItem class:
- The name property : A single and unique identification that won’t be displayed
- The label property : A text label that will be displayed in the menu
- The data property : An object of any kind, containing information regarding the selected item on the menu
In addition to the selection event, the elements of the menu also generate a display event. The display event is generated a moment before a drop- down menu is rendered by Flash Player. This event allows you to update the content of the menu before it is displayed. You can register the display event both on the instance of the NativeMenu class that contains the menu and one of its items.
A good example of how to use the display event is in a menu that lists the recent web pages that the user has visited. Each time the user accesses the list, the application regenerates the list by checking which pages have been visited lately. It is also possible to use the display event to disable or hide the items on the menu when necessary. You might want to do this if the user doesn’t have the necessary privileges to access some of the functions of your application.
Creating a native menu
When you work on native menus in AIR, you always deal with instances of the NativeMenu class. To create a native menu, start up Flash CS4 and open the AIR ch06p01.fla project . The project has been set up so that it doesn’t automatically declare the variables of the elements on the screen. This option is defined by the Automatically declare stage instances check box in the Advanced ActionScript 3.0 Settings panel, which can be reached through the Publish Settings panel .
The class creates a native menu and associates it with the custom menu button with the instance name button as a context menu on the stage. To create a menu object, you have to create an instance of the NativeMenu class, like this:
var menu:NativeMenu = new NativeMenu();
To populate the native menu with some elements, you can use the following addItem() and addSubMenu() functions , which respectively allow you to add commands and submenus to the native menu:
// add a NativeMenuItem to native menu
menu.addItem( new NativeMenuItem( "menu element" ) );
// add a submenu to native menu
menu.addSubMenu( new NativeMenu(), "submenu element" );
Following is the code of the Ch06p01.as class . Notice the details: as you may already know, the class defines the package it belongs to. Then it declares all the classes it has to import to make the ActionScript code work properly:
package com.comtaste.foed.essentialair.chapter6
{
import fl.controls.Button;
import fl.controls.TextArea;
import flash.display.MovieClip;
import flash.display.NativeMenu;
import flash.display.NativeMenuItem;
import flash.events.Event;
import flash.filesystem.File;
Among others, the NativeMenu and NativeMenuItem classes are imported, from the flash. display package, making it possible to create and use the native menus.
The following class declaration shows that you are extending the MovieClip class . This is necessary because the class will be associated with the Flash project and therefore has to define the properties and functions it needs to be rendered by Flash Player.
// class declaration
public class Ch06p01 extends MovieClip
{
Now that the class has been defined, you can declare the variables that the elements of the class can use. The variables have to include all the instances of the objects on the stage that have been assigned an ID. Here’s the code:
// onstage components
public var button:Button;
public var output:TextArea;
// class properties
private var menuRoot:NativeMenu;
The menuRoot variable will contain the native menu that will be associated with the button button . The menu will be created and associated with the button in the constructor method of the class.
The constructor method of a class is a method with the same name as the class. Flash Player executes this method automatically each time an instance of the class is created. That’s why it’s called a constructor method. Its purpose is to allow the initialization of the elements and the functions the class needs to make the class work. This method doesn’t have a return type, as it can’t be used arbitrarily. It can only be launched when the class is instantiated. Also note that the constructor method must be public in ActionScript 3.
Here’s an example of how to use the menuRoot variable :
// class constructor
public function Ch06p01()
{
// call super class constructor
super();
// generate native menu to use
createNativeMenu();
// assign menu to right- click on button
button.contextMenu = menuRoot;
}
Next, launch the createNativeMenu() method in the class constructor. This method is in charge of instantiating and populating the native menu. Then you assign the menuRoot variable, which contains your native menu, to the contextMenu property of the component of the Button class . Assign an instance of a native menu to this property. Doing so tells Flash Player that the relevant menu should be displayed on the button when the user right- clicks (on Windows) or Ctrl- clicks (on the Mac).
To create the native menu, the createNativeMenu() method executes the following instructions:
// create a complete native menu
private function createNativeMenu():void
{
An instance of the NativeMenu class is assigned to the menuRoot variable as follows:
// instantiate main menu object
menuRoot = new NativeMenu();
Then two submenus are added to the native menu you’ve just created. The two following functions have been prepared to generate the submenus:
createFirstSubMenu()
createSecondSubMenu()
These functions are in charge of creating the submenus and returning the instances. Here’s the code:
// append subMenus to menu root
menuRoot.addItem( createFirstSubMenu() );
menuRoot.addItem( createSecondSubMenu() );
}
This is the complete ActionScript class that you have created:
package com.comtaste.foed.essentialair.chapter6
{
import fl.controls.Button;
import fl.controls.TextArea;
import flash.display.MovieClip;
import flash.display.NativeMenu;
import flash.display.NativeMenuItem;
import flash.events.Event;
import flash.filesystem.File;
public class Ch06p01 extends MovieClip
{
// onstage components
public var button:Button;
public var output:TextArea;
// class properties
private var menuRoot:NativeMenu;
public function Ch06p01()
{
super();
// generate native menu to use
createNativeMenu();
// assign menu to right- click on button
button.contextMenu = menuRoot;
}
// create a complete native menu
private function createNativeMenu():void
{
// instantiate main menu object
menuRoot = new NativeMenu();
// append subMenus to menu root
menuRoot.addItem( createFirstSubMenu() );
menuRoot.addItem( createSecondSubMenu() );
}
}
}
In the second part of The Essential Guide to Flash CS4 AIR Development Highlight you'll learn how to create a submenu item, using the NativeMenuItem class.
The original article is published on Marco Casario's blog : Creating AIR native menu with Flash CS4 - Part 1 (The Essential Guide to Flash CS4 AIR Development Highlight)
Subscribe to Adobe Flex Journal Email News Alerts
Subscribe via RSS
