Designing the Procedure Logic › GUI Event Processing › Characteristics of Event Handlers

Characteristics of Event Handlers

Event handlers have the following characteristics:

• Events are owned by the procedure and therefore have a name that is unique within the procedure.
• An event handler shares views with the procedure. All event handlers belonging to a procedure have access to its views. Therefore, there is no view matching between a procedure and an event handler.
• A single event handler may be invoked by multiple controls. They are shareable within a procedure.
• All types of action diagramming actions may be specified in an event handler.

The CA Gen generated window manager detects events. It calls the appropriate event handler. When the event handler completes execution, it returns to the window manager without having entered the procedure.

When the user or the system triggers an event, its code is immediately executed. An event handler's execution is similar but not exactly like a procedure's execution.

After an event handler executes, the following actions occur:

• Local and entity action views are cleared
• Commits take place
• Exit states are interrogated
• Export views are displayed

The default for the movement of the views is that the import views are automatically moved to export views, except for the changed event, when views remain as they were before the event logic was executed. You can change this default.

There is a reason for the exception made for the changed event. Based on certain conditions, the prior value in the field should be displayed instead of what was entered. For example, a default value may be displayed in an entry field. If the user makes an incorrect entry, the default value should remain displayed, not the entry that was made. This means that most action statements in event handlers should reference the export view. (However, that procedure logic must still move import views to export views.)

Further events (such as Open or Close) that may be triggered by an event are placed in a queue and executed in turn after the logic in the initial event handler has completed.