Figure 1: Ordering Control

Creating a custom control allows us to do a number of things that we just cannot do with a normal HTML form element:

Figures 2, 3 & 4: Showing lower bounds, non-default value and upper bounds

• Display relevant information instead of certain values, such as showing Automatic at 0 in Figure 1
• Show when the upper and lower bounds are reached, for example at -100 and 100 as per our example
• Allow the user to reset the value to the default or previous setting
• Give some inkling into how the control should be used

Controls

Figure 5: Annotated Ordering Field

• Previous/Next: update the value of the field to the previous or next value in the range
• Reset: reset the value to the pre-defined default value
• Display: allow us to display feedback or custom messages based on the value of the field we’re manipulating

This interaction is fairly rudimentary and not very exciting to say the least. We really want to provide more desktop-like interaction via our own custom controls such as the ability to click-and-hold a button in order to scroll through available values. With such a control, in the majority of desktop applications, when the button is held the action that button denotes will be repeated after a short delay usually with increasing speed the longer it’s held. We can emulate this in JavaScript using a timeout to create the pause and a modifier to decrease the length of this pause and in turn increase the speed with which the actions are executed.

Code Snippit 1 contains a brief outline of how to create a mechanism for firing events when a button is held.

<script type="text/javascript">
    var timeout          = 1000;
    var timeout_limit    = 200;
    var timeout_speedup  = 1.5;
    var default          = 0;
    var lower_bounds     = -100;
    var upper_bounds     = 100;

    function setView( str, element ) {
        // Update the ordering element setting the values and
        // icons as necessary
      ...
    }

    function updateVariable() {
        // Update variable
        order        = document.getElementById( "ordering" );
        order_disp   = document.getElementById( "order_disp" );

        // Update variable
        order.value  = order.value + 1;

        // Check Bounds
        if( order.value >= upper_bounds )
            setView( "upper_bounds", order_disp );
        elseif( order.value == default )
            setView( "Default", order_disp );
        else
            setView( "" + order.value, order_disp );

        // Start firing click-and-hold events
        if( timeout > timeout_limit )
            timeout = max( timeout / timeout_speedup, timeout_limit );
        t = setTimeout( updateVariable, timeout );
    }

    function buttonStop( t ) {
        timeout = 1000;
        clearTimeout( t );
    }
</script>

timeout is the time between calling button events, the timeout_speedup modifier is used to recalculate the timeout on each event in order to increase the speed with which the event is fired. We set a lower limit, timeout_limit, to ensure that the events aren’t called too quickly to update the display and to give the user time to react once they near their desired value. A plot of time between ticks against ticks is shown in Graph 1, as you can see it quickly ramps up so timeout is set to the lower limit, much like you would expect from a desktop application’s click-and-hold button interaction.

Graph 1: Timeout vs. Ticks

Code Snippit 2 shows sample HTML used to create the next button with the appropriate onmousedown, onmouseup and onmouseout JavaScript calls to add the desired functionality to the button.

<img
    title="Next" src="images/icons/arrow_right.png" alt="&rarr;"
    
    onmousedown="updateVariable();"
    
    onmouseup="buttonStop( t );"
    
    onmouseout="buttonStop( t );"
/>

We use both onmouseup and onmouseout to ensure that the click-and-hold behavior ceases when the user either releases the mouse button or moves the cursor off the control.

Figure 6: Textentry into ordering field

Feedback

Here’s where our custom controls can really begin to shine, we can give the user direct feedback in the control that they’re manipulating in real-time. Sure we can do this with JavaScript as it stands, but extending beyond the “red border = wrong” methodology we can give visual cues to the user to show that they’re trying to do something thata’s wrong and what specifically is wrong with what they’re doing.

Showing the bounds of the field is easy using the visual cues we’ve detailed in Figures 2 & 4. Other visual cues we can use are that of text/background colouring to show that an error occurred. We can also, using the same timeout methods used for the click-and-hold interaction, display useful messages to the user for a brief time before correcting their mistakes telling them what they did wrong and why their entries have been changed, Figure 7.

Figure 7: Error detection and correction

It’s only an example!

Figure 8: Other possible controls?

What’s the point? There’s so much we can do nowadays in terms of interaction, even on the web. Try to add a little bit of interactive zest to your HTML controls, it makes everyone’s experience that little bit easier and better.

Thanks for reading,
- Chris

I’ve only been playing with it for a short while, but my initial impressions are that it’s pretty damn sweet.

It allows you to post things straight from flickr, downloading your photo stream and showing it to you, so there’s no need to go to the flickr site and grab the photo url or the code you want to paste into your post, you simply have to drag in the photo!

Anyway, I’m impressed and you should get yourself a copy to try it out.
- Chris