Helm uses the book paradigm. A book is a Helm program which consists of forms and pages. Like cards in CanDo, forms and pages are windows containing various objects that make up the user interface.
Forms are a powerful element of Helm. If several pages are needed that contain some common objects, yet some different objects also, then forms are the ticket. A form can be designed that contains the common objects, then several pages can be created that each inherit the objects of the form. Additional objects can be added to the individual pages to complete the interface. If these pages all need a new object later, it can simply be added to the form, and it will automatically appear on all the child pages. This is an object-oriented approach to building the user interface. To simulate this in CanDo, a card can be created containing the common objects. This card can be copied several times and additional objects added to the copies. If a new object is needed later, it has to be added to one card and then copied to all the other cards.
Like CanDo, Helm's objects can respond to certain events. However, in Helm, there are two ways to respond to an event. One way is to use a script. Another is to create a list of actions. Actions are essentially pre-written scripts that perform common tasks and can be sequenced interactively using the mouse (more about this later).
Helm takes a totally different approach. A new book starts with a blank page, but the tools for adding the interface objects are available via pull down menus attached directly to the page. All of the pull down menus remain available for the user of a book unless they are removed or disabled by the programmer. To make the editing of a page easier, various tools are available via the Tools menu. When a menu item in the Tools menu is selected, a small window appears on top of the current page that contains tools for easing the task of interface building. Figure 2 shows several of the tools windows open on a page.
Helm comes with a special book called Bookshelf. If this book is in the same directory as Helm, it will be executed automatically each time Helm is run. Bookshelf is a simple traffic cop program that allows other books to be executed by clicking on a button (Figure 3). New books can be added to the bookshelf. CanDo does not come with an equivalent program, but one can be created quite easily by creating a button object, duplicating it several times, and adding a short script to each of the buttons' OnRelease events that use the LoadSubDeck and OpenWindow commands. (I plan to cover these commands in detail in a future installment of my CanDo series.)
Helm has a chart object that allows data to be viewed in several formats such as bar, scatter, pie, line, and area. It also has many different selector objects. Some of these are Calendar, Check Box, Clock, Cycle (a real rollo button with a right mouse button pop-up menu), Item Slider, Matrix, Multiple Choice, Palette, Pop-up Menu, and Radio Box. More are available. Some selector objects are available in CanDo; but not nearly as many as in Helm.
CanDo has a few objects that Helm doesn't have. It has a KeyInput object that lets you trap certain key combinations and execute scripts. CanDo also has an Animation object and a Sound object. The former allows scripts to be executed at user defined frames during the playing of a BrushAnim. The latter allows scripts to be executed when an 8SVX sound begins to play and another when it ends.
Helm addresses several of the complaints I have had about CanDo. First, objects can be selected, sized, and moved by simply clicking on the object and dragging the mouse. This is a real time saver when rearranging a user interface. Second, label text can be part of an object rather than having to write a script to add the text. This means that when an object is moved on the page, its label text goes with it. No more editing a script to keep it positioned correctly. Third, Helm has Shape objects. Lines, curves, ovals, triangles, rectangles, polygons, and arrows can be added to the screen by drawing them. As with a structured drawing program, these objects can be moved and sized easily using the mouse. You can draw various shapes on the screen with CanDo, but it creates a script rather than an editable object. Using this method, a shape can only be changed by editing the script or deleting it and starting over. Fourth, Helm allows several objects to be selected and grouped together. They can be ungrouped later if necessary. Also, several objects can be saved to disk as a custom object and then loaded into another book with ease.
One thing I dislike about Helm is that its text entry fields are not Amiga standard whereas CanDo's are. The text in the field cannot be deleted using the RightAmiga-X key combination. Rather, the text has to be selected with the mouse and cleared, or it has to be removed with the backspace or delete key.
As mentioned earlier, Helm can respond to an object event in two ways. Actions can be executed or a script can be executed. Actions are built-in routines that can be selected with the mouse (Figure 4). Several actions can be sequenced together for event handling. This is nice for simple event handling, but for more complex tasks, scripts are required. In CanDo, a script must be written to handle an event.
CanDo and Helm each have a very large number of commands and functions that can be used within scripts. They handle such things as numeric and string manipulation, I/O, graphics, sound, music, etc. CanDo takes a standard approach to programming a script. Examples can be seen in my regular CanDo articles. Helm, however, allows both a non-standard and a standard approach to programming a script. For instance, if you wanted to assign a value of 12 to the variable MyVar in CanDo, you would enter:
Let MyVar=12
In Helm, you could enter one of the following:
MyVar=12 put 12 into MyVar
Helm also introduces the concept of a container. A container is like a variable except it can contain much more than the standard numbers and text. Containers can hold any type of object that Helm supports such as buttons, image fields, text fields, pop-up menus, etc. The properties of a container's object can be changed with the Set command and obtained with the Get command. This is a very powerful and consistent way of handling object data.
The script editors in CanDo and Helm are very similar in that they each support cut and paste, search and replace, and other common editor tasks. CanDo uses a separate script for each event that an object can handle. Thus, if a button recognizes both a Click and a DoubleClick event, the event handling for each is in a separate script. Helm objects only have one script containing all of the event handling routines.
CanDo has Editor Tools along the right-hand side of the editor window (Figure 5). This is useful for inserting the names of files or having CanDo write small scripts rather than typing them in. Other tasks can also be handled via the Editor Tools. Helm does not have an equivalent feature.
Commands in CanDo have to reside on one line regardless of how long the line is. This can be a headache when printing scripts since some lines can become quite long. Helm supports a free-form style that allows commands to be wrapped around to another line or combined together on one line. This can make for some unreadable code if the programmer does not adopt a formatting standard.
Helm has a built-in paint program. It is not as powerful as something like DeluxePaint IV, but it has all the basic tools expected in a paint program. Image manipulation tools are also available. All of these tools can be used in an application. Helm allows many different transition effects between pages. These include wipes, scrolls, slides, dissolve, venetian, and more. The effect area can include the entire page or a smaller user-defined area. None of these tools are available in CanDo.
CanDo supports MED, OctaMED, Sound/Noise/ProTracker, and Oktalizer song files but does not support SMUS files. Helm supports SMUS files and nothing else. However, Helm has its own internal note player. Within a book, a series of notes, designated with letters of the alphabet, can be played. Embedded codes can be used to set volume, channel, MIDI channel, note duration, etc. This can be very useful for short single track musical scores.
CanDo has no direct support for narration, but it can be added. The AmigaDOS 2.04 MountList file in the DEVS: directory has a device named SPEAK: that can be mounted. This device, which is implemented as a handler, allows ASCII text to be copied to it. It in turn translates the text and speaks it. Within CanDo, a new write only file can be opened to this device, and text can be sent to it via the FileWriteChars or FileWriteLine command. Options can be added to the end of the device name such as "SPEAK:OPT/r/s100". This example sets the robot voice with a fast speaking speed. The options that are available can be found in any AmigaDOS Manual that documents the Say command.
CanDo does not support hypertext. I believe it could be simulated, but I would not want to be the one to attempt it.
CanDo does not directly support printer setup and reporting. The AmigaDOS Preferences programs Printer, PrinterGfx, and PrinterPS must be executed from within a CanDo deck using the Dos command to get equivalent printer setup functionality. For an example of how to create a report in CanDo, see CanDo Part 7 in V9N3.
CanDo has a separate utility named ThePrinter that can read a CanDo deck and then print its contents to a file or a printer (Figure 8). The print-out contains information about all the deck's cards and objects, including locations, text, text styles, etc. as well as a listing of all the scripts in the deck.
Helm allows scripts and graphic images of its pages and forms to be printed, but there is no way to print information about a book's forms, pages, or objects. This is very inconvenient if you need to fully document a program's content.
Helm books can be distributed without a fee regardless of whether they are commercial or not. A program named HelmBrowser, which is included with Helm, allows anyone to use a Helm book without owning Helm. HelmBrowser is freely distributable.
Since Helm allows all of the tools of the program itself to be available to the end user (HelmBrowser does not include development tools), it allows the programmer to set a user level. Each level restricts the user in different ways. This allows the programmer to give the user just enough freedom to use the book effectively without messing it up.