CanDo vs Helm

by Randy Finch

I recently heard one of my favorite philosophers say that the hardest part of writing his latest book was deciding what material to leave out, not what to put in. This is the way I feel when writing a comparative article such as this. CanDo and Helm are both so feature-filled that it is impossible to compare everything in the limited space of a magazine article. With this in mind, let me forge ahead with the comparison. I will be discussing CanDo v2.51 from INOVAtronics and Helm v1.37 from Eagle Tree Software.

Installation

CanDo and Helm are extremely easy to install. Both use the Installer program from Commodore. As I mentioned in CanDo Part 4 (V8N12), CanDo does not allow the user very many choices during installation. Helm, on the other hand, allows a variety of choices. For example, the user can select which sample programs to install and decide whether or not to overwrite an existing shared library.

Paradigms

CanDo uses the deck paradigm. A deck is a CanDo program which consists of one or more cards. A card is basically a window containing various objects that make up the user interface. Each card and its objects recognize certain events such as mouse button clicks. When an event takes place, a script can be executed. This gives the program functionality.

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).

Interfaces

CanDo starts a new deck with a blank card. The tools for adding interface objects to the card are on the Main Control Panel, which is on a separate screen that partially covers the card (Figure 1 ).

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.)

Objects

CanDo and Helm both have many similar objects that can be added to a card or a page. They include such things as buttons, text entry fields, timers, menus, list boxes, etc. However, there are some objects that only one or the other have available.

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.

Event Handling

CanDo and Helm both can detect and respond to a number of object events in a program. Generally, Helm supports a few more events than CanDo. For instance, Helm can detect a Right Mouse Button (RMB) click (MenuDown or MenuUp) for some objects. CanDo can detect a RMB event through its RightMouseButton object but it is generic to the whole card rather than object specific. However, CanDo can detect a Drag event; Helm cannot.

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.

Graphics

CanDo and Helm both support the new AGA graphics modes. Also, as you would expect, CanDo and Helm support IFF ILBM bitmap files, Brushes, ANIM-5 animations, and AnimBrushes. Helm supports all of these formats directly; CanDo supports all but the ANIM-5 format directly. With CanDo, ANIM-5 files must be played using an included utility named AnimPlayer. As mentioned earlier, CanDo has an object available that allows scripts to be synchronized with a BrushAnim. AnimPlayer allows synchronization via ARexx message passing (see CanDo Parts 5 and 6 in V9N1 and V9N2).

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.

Sound and Music

CanDo and Helm both support 8SVX sound files. As mentioned earlier, CanDo has an object available that allows scripts to be synchronized with the beginning and ending of a sound playback.

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.

Narration

Helm has direct support for the narrator. However, as you probably know, the translator shared library, which translated ASCII text into phonemes, and the narrator device, which turned phonemes into speech, are no longer distributed with AmigaDOS. They were last included in AmigaDOS 2.04. If you have the appropriate files from some earlier OS disks, you can copy them to your system disk and use them with Helm. Many different aspects of how the speech will sound can be adjusted via a requester (Figure 6). Also, narration can be synchronized with the playback of an animation.

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.

Hypertext

Helm supports hypertext. Text within a textfield can be selected and an attribute set to hypertext, just as it would be set to bold or italic. Actions or a script can then be attached to either a SelectUp or SelectDown event. The appearance of hypertext is user selectable.

CanDo does not support hypertext. I believe it could be simulated, but I would not want to be the one to attempt it.

AmigaGuide

CanDo and Helm use AmigaGuide for both their own internal help systems and for user programs. Helm allows AmigaGuide files to be displayed from an action or from a script. (For more information about using AmigaGuide files, see CanDo Part 7 in V9N3.)

System Support

CanDo has quite a bit of support for AmigaDOS that is missing in Helm. For instance, CanDo supports AppEvents. This allows icons to be dragged to a CanDo application window on the Workbench. The application receives a list of icon names, and it can respond appropriately. CanDo supports loading, manipulating, and saving icon files (the files ending in .info). This includes saving a ToolType list. Commands are available that allow an application to obtain a current device list, directory list, buffer list, and startup messages. The pointer can be set to a different image and turned on and off. Also, CanDo uses the standard file requester in asl.library; Helm does not. For C programmers, CanDo has two system variables that contain the address of the current screen and the current window.

Data Handling

As I discussed in detail in CanDo Part 2 (V8N10), CanDo supports user-defined variables, sparse arrays, and documents. These can be combined together to provide a convenient way for a user to add, delete, change, load, and save data. Helm takes a totally different approach. Data is saved automatically. Whenever a page with input fields is filled in or changed by the user, the new data is saved to the book file. Although this is extremely simple from a programmer's perspective (nothing has to be done), I am not yet sure if I like this. For instance, when I am testing a program, I like to enter a lot of erroneous data. I almost never save the data since it is not real data. If I do save it, I create a trash file that can be deleted later. With Helm, the erroneous data goes right into the book file. To revert back to actual data, a copy of the book must be created with no data in it, or the erroneous data must be deleted page by page.

Printing

Helm has some built-in tools for printing book data to a printer. It allows essentially all of the user's printer preferences, both text and graphics, to be set from within a book (Figure 7). Helm also supports Postscript output. Custom reports can be designed and printed.

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.

Distribution

In order to distribute a CanDo deck to a person who does not own CanDo, a runtime library is needed. INOVAtronics will provide one that can be distributed free if the program is public domain or shareware. However, if the program is a commercial product, the developer must pay a distribution fee.

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.

Closing Comments

I think I'll end it there. I hope this gives you a feel for the similarities and differences of CanDo and Helm. As I said at the beginning of this article, it was not possible to cover all aspects of these programs since they have so many features. I personally like both products and intend to continue using both, choosing the one that is most appropriate for an application based on their features. If you are brave, you could use both products in one application since both products support ARexx. If you like developing applications, you need to have both of these products in your software library. Helm can be purchased for less than $100 and CanDo for about $130. This is not too much to pay for these powerful authoring tools.


Back to list of articles
Back to Randy Finch's Home Page
Last modified on April 1, 1996
Randy Finch at webmaster@rcfinch.com