Imaging Experts

Adding Configurable Keyboard Shortcuts to your Java Application

In the last entry, I wrote a very basic menu-driven Java program, which allows the user to change the background of the Frame. In this entry, I'll go over how to add keyboard shortcuts to this app. 

We'll just have ShortcutFrame implement KeyListener and add a keyPressed(KeyEvent) method.

Our class declaration is now as follows:

public class ShortcutFrame extends Frame
    implements KeyListener

in the first line of the constructor we add

   addKeyListener(this);

Then we need to implement the three methods for KeyListener.

To get started, I'll use the Source -> Implement Methods feature of Eclipse, which is really useful in these cases. This takes care of a lot of busy work.

I'll leave keyTyped() and keyReleased() methods empty. I'll only flesh-out the keyPressed method.

public void keyPressed (KeyEvent event)
    {
        char eventChar = event.getKeyChar();
        int eventCode = event.getKeyCode();
        if (eventChar == 'r')
        {
            performCommandRed();
        }
        else if (eventChar == 'b')
        {
            performCommandBlue();
        }
        else if (eventCode == KeyEvent.VK_PAGE_DOWN)
        {
            performCommandSwitch();
        }
    }   

Now imagine that a new customer wants this exact same program. But, they want the keyboard shortcuts to be as follows:

  Hit the '1' key for Red
  Hit the '2' key for Blue
  Hit ctrl PAGE_DOWN to cycle.
 
You need to keep the one code base, but you need multiple keystroke sets.

I had to solve this same problem. The first thing I thought of was, how to come up with a language to define key strokes. Something like this:

param name="redKey" value="R"
param name="blueKey" value="1"
param name="switchKey" value="CTRL-PAGE_DOWN"

I thought about the best way to define most of the key combinations. Then I figured someone must have already solved this problem, so I did some searching and got a hit on the Javadoc page for javax.swing.KeyStroke. The method that interested me most was getKeyStroke(String s)

There is a language to define keystrokes:

getKeyStroke (String s):

Parses a string and returns a KeyStroke. The string must have the following syntax:
    <modifiers>* (<typedID> | <pressedReleasedID>)

    modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
    typedID := typed <typedKey>
    typedKey := string of length 1 giving Unicode character.
    pressedReleasedID := (pressed | released) key
    key := KeyEvent key code name, i.e. the name following "VK_".
   
If typed, pressed or released is not specified, pressed is assumed. Here are some examples:
     "INSERT" => getKeyStroke(KeyEvent.VK_INSERT, 0);
     "control DELETE" => getKeyStroke(KeyEvent.VK_DELETE, InputEvent.CTRL_MASK);
     "alt shift X" => getKeyStroke(KeyEvent.VK_X, InputEvent.ALT_MASK | InputEvent.SHIFT_MASK);
     "alt shift released X" => getKeyStroke(KeyEvent.VK_X, InputEvent.ALT_MASK | InputEvent.SHIFT_MASK, true);
     "typed a" => getKeyStroke('a');

So now I'll define three static constants for my three key strokes;

    private static KeyStroke gKeystrokeRed = KeyStroke.getKeyStroke("pressed R");
    private static KeyStroke gKeystrokeBlue = KeyStroke.getKeyStroke("pressed B");
    private static KeyStroke gKeystrokeSwitch = KeyStroke.getKeyStroke("PAGE_DOWN");

my keyPressed method looks like this:

  public void keyPressed(KeyEvent event)
    {
        KeyStroke myKeyStroke = KeyStroke.getKeyStrokeForEvent(event);
        if (myKeyStroke.equals(gKeystrokeRed))
        {
            performCommandRed();
        }
        else if (myKeyStroke.equals(gKeystrokeBlue))
        {
            performCommandBlue();
        }
        else if (myKeyStroke.equals(gKeystrokeSwitch))
        {
            performCommandSwitch();
        }
    }

Now if I want to change any of these, I can read in an Applet parameter.

        ...
        getKeyStrokeParameter(applet, "keyStrokeRed", gKeystrokeRed);
        getKeyStrokeParameter(applet, "keyStrokeBlue", gKeystrokeBlue);
        getKeyStrokeParameter(applet, "keyStrokeSwitch", gKeystrokeSwitch);
        ...   
      
   
  public static void getKeyStrokeParameter(Applet applet,
                                             String param,
                                             KeyStroke shortcut)
    {
        String paramValue = applet.getParameter(param);
        if (paramValue != null)
        {
            shortcut = KeyStroke.getKeyStroke(paramValue);
        }
    }
   
   
Now anyone can override the keyboard shortcuts with whatever they like, via applet parameters.

-Alex

Colors, Events, and System.out.println

Let's say you are given the following task

Develop a Java Applet that brings up an empty window. Allow the user to change the background color of the window by using a Menu.

If the user chooses Menu -> Color -> Blue,
* Change the background to HTML color "071aaa".
* Print the String "Blue" in the Java Console

If the user chooses Menu -> Color -> Red,
* Change the background to HTML color "ff1a00".
* Print the String "Red" in the Java Console

OK. Sounds pretty easy. Lets make our Frame class.

The first thing I want to do is define constants for those Colors. A few years ago, I was only really familiar with the java.awt.Color constructor that took three integer values: one each for red, green and blue. If I was given an HTML color to display, like our blue "071aaa" I would have had to translate that HTML hex string to the three integers. I would have used Photoshop or a color web site like this. Recently I learned how to directly pass the hex value to the Color constructor that takes in a single integer value. All you have to do is pass in an integer in hex format like this

  private static final Color BLUE_COLOR = new Color (0x071aaa);
 
That's much easier than translating to RGB. The reason I use a static Color constant is so that we don't go reconstructing a new Color object every time the menu item is selected. I've seen a lot of code out there where the programmer calls "new Color(r,g,b)" every time they need that Color. That's a lot of excess object construction.

The ShortcutFrame code:

public class ShortcutFrame extends Frame
{
    private static final Color RED_COLOR = new Color (0xff1a00);
    private static final Color BLUE_COLOR = new Color (0x071aaa);
    MenuItem miBlue;
    MenuItem miRed;

    public ShortcutFrame(Applet parentApplet)
    {      
        MenuBar menuBar = new MenuBar();
        Menu colorMenu = new Menu("Color");
        miBlue = new MenuItem("Blue");
        miBlue.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                performCommandBlue();
            };
        });
        colorMenu.add(miBlue);
        miRed = new MenuItem("Red");
        miRed.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                performCommandRed();
            };
        });
        colorMenu.add(miRed);
        menuBar.add((colorMenu));
        setMenuBar(menuBar);
    }

    private void performCommandRed()
    {
        setBackground (RED_COLOR);
        log ("Red");
    }

    private void performCommandBlue()
    {
        setBackground (BLUE_COLOR);
        log ("Blue");
    }

    public void log (String output)
    {
        System.out.println (output);
    }

}

A few notes here.

• I'm using "anonymous inner classes" to perform the action listening for the menus. A lot of programmers will use the old paradigm of having one global listener for all of their buttons and menu items. This makes for one pretty ugly actionPerformed() method with a whole bunch of if / elses. The inner-classes allow one listener per UI element, no more if / else trees. These anonymous classes will show up as ShortcutFrame$1.class and ShortcutFrame$2.class at compile time.
• Within the anonymous listener classes, I'm not performing the actual menu commands, I'm simply dispatching a method call which does the actual work, i.e. performCommandBlue. This makes the anonymous listener classes a lot cleaner, and also allows these commands to be called by keyboard shortcuts!
• I'm not calling System.out.println directly in my performCommand methods. Instead, I'm calling a log method which does the printing. This way later on, when I want to redirect the output somewhere else, I only have one place to change this. Also if I want to turn off printing, I only have one line to comment out. An even better implementation would be to use the java.util.logging.Logger class. But that's for another blog entry.

In my next entry, we'll look at how to add configurable keyboard to our application.

-Alex

Playing the Document Waiting Game?

How much time do you spend every day retrieving and opening files?

As a short exercise, estimate, on average, how many documents (such as Word or PDF files) you retrieve from a server or CMS system each day and the number of different applications required. Now, average out how many minutes a day you spend waiting for files to load, then multiply that over the course of a year. Finally, consider what that means when extended across your group, or your entire organization.

Bottom line is that we spend a lot of time waiting.

Because viewing is an important part of your everyday process and can impact efficiency greatly, I urge you to review your department's or group's workflow today.

By implementing a web-based viewing solution, you can make an immediate impact on your productivity and quickly realize ROI through a reduction in the number of clicks needed to retrieve documents and the time spent loading those files. Your group or company will be more productive and complete more tasks each day.

If you would like to start raising your company's productivity, request an evaluation of our high-speed FlexSnap web viewers.

-Simon