Keyboard Keys

Keyboard Keys

In this section, we introduce you to the keys of the phone keyboard.
Although there is nothing particularly difficult in registering the click of a
key, there are several things worth noticing.
First, a single physical key may produce different results based on the
keyboard mode: for instance, a key might produce an upper or lower
case ‘a’ depending whether some other key is active. Second, there are
several different key events: the user can select a key, hold it down and
release it – all these events can be registered separately.
With the help of the next three examples, we show three different
approaches to programming keyboard keys. Each example takes a slightly
different approach, but basically they all do the same thing:
• If the user presses the up-arrow key (navigation key up), a note dialog
tells us that the up-arrow key was pressed, as shown in Figure 5.2.
• If the user presses keyboard key 2, a note dialog tells us that key 2
was pressed.

Even though all three approaches are used here to accomplish the

same task, each of them is best suited to handle a particular use case:

• The first approach (Section 5.2.1) is handy when you need to handle

the clicks of only a few specific keys.

• The second approach (Section 5.2.2) is suitable if you need more

complicated processing of several keys.

• The third approach (Section 5.2.3) is a generalization of the second

and allows you to detect whether a key is clicked or continuously

held down.

Before we present the approaches, note one important prerequisite:

when you want to register any key event (except the left and right softkeys),

you need to assign the appuifw.Canvas object to the application body,

appuifw.app.body.

Canvas is a UI element that provides a drawable area on the screen

and provides support for handling keyboard key events. The Canvas

object can be instantiated as follows:

canvas = appuifw.Canvas()

appuifw.app.body = canvas

This creates a Canvas object named canvas which is then assigned

to the application body. As you may remember, Figure 4.1 illustrates

the application body with respect to the other parts of the standard S60

application UI.

The Canvas() function, which creates the corresponding object, takes

two optional parameters: redraw callback and event callback.

We can assign a callback function to both of these parameters. The

callback functions are called when the screen must be redrawn or

when a keyboard event occurs. The redraw callback() function

is described in Section 5.3 and the event callback function in

Sections 5.2.2 and 5.2.3.

Now, let’s dive into the three approaches on programming keyboard

keys.