What are dialog controllers?
Application forms are controlled by interactive instruction blocks called dialogs. These blocks perform the common tasks associated with the form, such as field input and action handling.
The interactive instructions allow the program to respond to user actions and data input.
Simple display (non-interactive)
DISPLAY BY NAME / TO instruction allows you to display program variable data
in the fields of a form and continue the program flow without giving control to the end user. This
is in fact not an interactive instruction, as it just displays data to the current form, and returns
immediately. However, it may be used in interactive instructions to display information to the end
user. UNBUFFERED mode of a dialog, you do not need to use the
DISPLAY BY NAME / TO instruction to synchronize program variables and form fields.The MESSAGE and ERROR instructions are also simple display
instructions without user interaction. These instructions are typically used to display a warning
message to the end user.
Modal dialogs and parallel dialogs
Interactive instructions can be implemented as modal or parallel dialogs. Modal dialogs control a given window, and that window closes when the dialog is accepted or canceled. The window displays on top of any existing windows which are not accessible while the modal dialog executes. Parallel dialogs allow access to several windows simultaneously; the user can switch from one window to the other. Parallel dialogs are mainly used to implement split views on mobile platforms.
The interactive dialog blocks
The singular MENU instruction handles a list of choices to activate a specific
function of the program. No field input is possible with this instruction. The user can only select
an action from the list.
The singular INPUT instruction is designed for simple record input. It enables
the fields in a form for input, waits while the user types data into the fields, and proceeds after
the user accepts or cancels the dialog.
The singular DISPLAY ARRAY instruction is used to browse a list of records. It
allows the user to view the contents of a program array of records, scrolling the record list on the
screen and choosing a specific record. DISPLAY ARRAY implements by default a
read-only list of records, but can be extended to become a modifiable list with list modification
triggers such as ON INSERT.
The singular INPUT ARRAY instruction supports record list input. It allows the
user to alter the contents of records of a program array, and to insert and delete records.
The singular CONSTRUCT instruction is designed to let the user enter search
criteria for a database query. The user can enter a value or a range of values for one or several
form fields, and your program looks up the database rows that satisfy the requirements.
The procedural DIALOG instruction (placed in the program flow) allows you to
combine several INPUT, DISPLAY ARRAY, INPUT ARRAY
and CONSTRUCT functionality within the same form.
The declarative DIALOG block (defined in a module at the same level as a
function) allows you to implement individual MENU, INPUT,
DISPLAY ARRAY, INPUT ARRAY and CONSTRUCT
functionality, that will perform in parallel on several forms, when used with the START
DIALOG and TERMINATE DIALOG instructions. Declarative
DIALOG blocks can also be associated with a procedural DIALOG
instruction through the SUBDIALOG clause, it will then act as a procedural
DIALOG sub-dialog. See Using declarative dialogs.
Dynamic dialogs
When the form structure and field definitions can only be determined at runtime, it is possible to implement Dynamic Dialogs, using generic code that will control a form generated on the fly.
Dynamic dialogs can implement all types of dialogs like static dialogs do. However, this feature should only be used in specific cases where regular static dialog instructions cannot be used. Static dialog code is more readable than generic code implementing dynamic dialogs. A generic record selection from a list (zoom) is the perfect candidate for a dynamic dialog.