Creating and accessing pop- up menus in AIR applications with Flash CS4

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.

Reading my previous AIR tutorials, you’ve worked with menus that are associated with tangible elements of your applications,
such as the following:

Context menus that are activated on objects on the stage

Context menus associated with icons in the system tray or dock bar

Menus associated with windows and menus of the application itself

AIR applications also allow you to create pop- up menus . These are native menus like all
the other ones you’ve seen so far—the only difference is that pop- up menus aren’t natively
associated with any element on the interface of the application. It’s up to the developer to
define and implement the logic and the way in which a pop- up menu can be activated. An
AIR application can have any number of pop- up menus.
You can show a pop- up menu anywhere on the stage. It can be activated in the following
ways: if the user clicks a button, if the mouse rolls over any object, if the user presses
a combination of keys, and on any other condition you want for your application.

Activating pop- up menus

The NativeMenu class has the display() method to activate a pop- up menu. Every time
this method is called, the pop- up menu appears at the specified coordinates. The display()
method requires the three following arguments:
Destination stage : Specifies which stage has to display the pop- up menu. If the
AIR application is on only one NativeWindow- type window, the destination stage is
automatically the window that displays the application. If you’re making a multiwindow
application, you will have to specify the stage of the window you want to
display the pop- up menu on.
Coordinate (X axis) : Specifies the position on the X axis of the pop- up menu. This
coordinate specifies the position from the top left corner of the menu. The coordinate
will apply to the stage you’ve specified as a first argument of the function.
Coordinate (Y axis) : Specifies the position on the Y axis where you want to display
the pop- up menu. This coordinate specifies the position from the top left corner of
the menu. The coordinate will apply to the stage you’ve specified as a first argument
of the function.

Creating pop- up menus

Open the ch06p05.fla project , which will allow you to create a pop- up menu. You can see
the stage of the application and the elements it contains in Figure 6-17. The point is to
obtain a native pop- up menu that will be displayed at specific coordinates in response to
a click of the button with an instance name of button. The menu will be also displayed in
response to the press of the M key on the keyboard.

To offer more flexibility to the user, two components of the NumericStepper class have
been provided, with a posX and posY ID. These components allow you to dynamically
change the coordinates where you want the pop- up menu to appear. Finally, there is
a TextArea with an output ID. From the beginning of this chapter, you’ve seen this component
being used as the destination of the messages that are generated during the execution
of the application.

Access the document class of the project by clicking the Edit class definition icon on the
Document Properties panel in Flash CS4. The class begins by defining its namespace and
specifying the following external classes it depends on:

package com.comtaste.foed.essentialair.chapter6
{
import fl.controls.Button;
import fl.controls.NumericStepper;
import fl.controls.TextArea;
import flash.desktop.NativeApplication;
import flash.display.MovieClip;
import flash.display.NativeMenu;
import flash.display.NativeMenuItem;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.filesystem.File;

public class Ch06p05 extends MovieClip
{

Before creating the constructor method, you define the class properties the application
needs. Among the properties, you’ll find a reference to every element on the stage of the
Flash project. You’ll also find the menuRoot property , which contains the instance of the
NativeMenu class you’ll use as a pop- up menu. The following code accomplishes these
tasks:

// onstage components
public var posX:NumericStepper;
public var posY:NumericStepper;
public var button:Button;
public var output:TextArea;
// class properties
private var menuRoot:NativeMenu;
The constructor method of the class instantiates and populates the native menu. Then it
registers the event listener functions that will activate the pop- up menu, as shown here:

public function Ch06p05()
{
super();

After calling the super constructor of the class, you call the createNativeMenu() method ,
which populates the pop- up menu. You also register the event listener function that will
be called when the user selects one of the items on the menu. Here’s the code:

// generate native menu to use
createNativeMenu();

Next, you’ll register two event listener functions. One will be used when the user presses
the keys on the keyboard, and the other is for the click event on the button on the stage.
Here’s the code for these event listener functions:

// assign event listener to key press
NativeApplication.nativeApplication.addEventListener(KeyboardEvent.KEY_UP,
showPopupMenuFromKeyboard );

// assign event listener to click on button
this.addEventListener( MouseEvent.CLICK, showPopupMenu );

}

The createNativeMenu() method instantiates and populates the pop- up menu in the
application. To populate the pop- up menu you use the same procedure as all the previous
examples. You assign an instance of the NativeMenu class to the menuRoot class property .
Then you create and add three objects of the NativeMenuItem class to the native menu.
Each element of the menu is registered on the menuItemSelected() method for when the
user selects it on the menu. The following code accomplishes these tasks:

// create a complete native menu
private function createNativeMenu():void
{
// instantiate main menu object
menuRoot = new NativeMenu();

// append items to menu root
var item1:NativeMenuItem = new NativeMenuItem( "Item 1" );
item1.addEventListener( Event.SELECT, menuItemSelected );

menuRoot.addItem( item1 );
var item2:NativeMenuItem = new NativeMenuItem( "Item 2" );
item2.addEventListener( Event.SELECT, menuItemSelected );

menuRoot.addItem( item2 );
var item3:NativeMenuItem = new NativeMenuItem( "Item 3" );
item3.addEventListener( Event.SELECT, menuItemSelected );

menuRoot.addItem( item3 );

}

Each time the user selects an element from the pop- up menu, the menuItemSelected()
method is launched. This accesses the text label of the object of the selected NativeMenuItem
class . The name of the selected element on the menu will appear in the TextArea on the
stage. Here’s the code:

// called on click on menu item selection
private function menuItemSelected( evt : Event ):void
{
var item:NativeMenuItem = evt.target as NativeMenuItem;

output.appendText( "CLICKED ON: " + item.label + File.lineEnding );
}

In the constructor method of the class, the showPopupMenuFromKeyboard() method is
linked to pressing the keys on the keyboard. This method will be launched each time the
application is active and the user presses any key. Here’s the code:

// called when user presses a key on his keyboard
private function showPopupMenuFromKeyboard( evt : KeyboardEvent ):void
{

Next, you assign the key the user presses to a local variable. To obtain the pressed key, you
use the static fromCharCode() method of the String class . You pass the value of the
charCode property , which is transported by the object of the KeyboardEvent class received
as an argument of the function to the method:

// access pressed key
var keyString:String =
String.fromCharCode( evt.charCode ).toLowerCase();

You check if the value associated with the key on the keyboard is the letter M. If it is, you
show the pop- up menu in the window of the application using the values of NumericStepper
components on the stage, with posX and posY as coordinates. Here’s the code:

// if key pressed is valid show pop- up menu
if( keyString == "m" )
{
menuRoot.display( this.Stage, posX.value, posY.value );
}
}

Finally, the showPopupMenu() method is registered on the click event of the button with
the instance name button in the class constructor method. When the user clicks the button,
it shows the pop- up menu at the coordinates that have been specified by the two
NumericStepper components on the stage of the application.

// called when button is clicked
private function showPopupMenu( evt : MouseEvent ):void
{

// show pop- up menu
menuRoot.display( this.Stage, posX.value, posY.value );

}

Now, go back to the Flash ch06p05.fla project to see the results of your work. Select the
Test Movie item from the Control menu to execute the application. Try clicking the button
or pressing the m key on your keyboard. You can see an example of the activated pop- up
menu in Figure 6-18.

This is the complete ActionScript class that you just created:

public class Ch06p05 extends MovieClip
{
// onstage components
public var posX:NumericStepper;
public var posY:NumericStepper;
public var button:Button;
public var output:TextArea;

// class properties
private var menuRoot:NativeMenu;

public function Ch06p05()
{
super();
// generate native menu to use
createNativeMenu();
// assign menu to click on button
NativeApplication.nativeApplication.addEventListener(
KeyboardEvent.KEY_UP, showPopupMenuFromKeyboard );
this.addEventListener( MouseEvent.CLICK, showPopupMenu );
}

// create a complete native menu
private function createNativeMenu():void
{
// instantiate main menu object
menuRoot = new NativeMenu();
// append items to menu root
var item1:NativeMenuItem = new NativeMenuItem( "Item 1" );
item1.addEventListener( Event.SELECT, menuItemSelected );
menuRoot.addItem( item1 );
var item2:NativeMenuItem = new NativeMenuItem( "Item 2" );
item2.addEventListener( Event.SELECT, menuItemSelected );
menuRoot.addItem( item2 );
var item3:NativeMenuItem = new NativeMenuItem( "Item 3" );
item3.addEventListener( Event.SELECT, menuItemSelected );
menuRoot.addItem( item3 );
}

// called when user presses a key on his keyboard
private function showPopupMenuFromKeyboard(
evt : KeyboardEvent ):void
{
var keyString:String =
String.fromCharCode( evt.charCode ).toLowerCase();
if( keyString == "m" )
{
menuRoot.display( this.stage, posX.value, posY.value );
}
}

// called when button is clicked
private function showPopupMenu( evt : MouseEvent ):void
{
menuRoot.display( this.stage, posX.value, posY.value );
}

// called on click on menu item selection
private function menuItemSelected( evt : Event ):void
{
var item:NativeMenuItem = evt.target as NativeMenuItem;
output.appendText( "CLICKED ON: " +
item.label + File.lineEnding );
}
} // close class
} // close package

The display() method of the NativeMenu class only works properly on Microsoft Windows
systems. Flash Player doesn’t work properly on Mac OS X systems, and displays the pop- up
menu on the cursor of the mouse instead of at the specified coordinates. This occurs if the
call to the display() function happens as a consequence of an event of the MouseEvent
class . If the call happens in response to other events, the application doesn’t display the
pop- up menu at all. In the next section, you’ll see how to create flexible native menus
defined via external configuration documents.