Conference bulova::decw_jan-89_to_nov-90

3527.0. "Multi-argument Operations in WIMP Environment" by CASEE::RAYNER (Doug -- OSAG/BCE, Valbonne, France) Thu Oct 25 1990 09:56

    This note is cross-posted in the DECwindows, Motif, and XUI
    conferences.

    We're trying to come up with a good technique for supporting
    multi-argument operations in a direct-manipulation interface.  If
    anyone has any creative ideas, or knows about techniques used by
    exisitng applications, we'd appreciate hearing about it.  I love to
    steal other people's good ideas!

    By way of example, suppose there is an operation called 'discuss'.  It
    takes 3 arguments: the forum for the discussion, the topic to be
    discussed, and the participants for the discussion.  Some of these may
    be objects displayed on the screen, and could be pointed to (e.g., the
    Notes Conference which would serve as the forum, an existing document
    which contains the subject matter to be discussed, a distribution list
    that represented the participants).  Others may be inferred (e.g., the
    participants might default to the default 'members' of the forum).  And
    some may be created/selected interactively after the operation is
    invoked (e.g., the topic might be created using an editor, the
    participants might be selected from a list of known users).

    I have seen a couple of approaches to this problem, but I feel that
    they each have disadvantages:

	Single selection + modal dialog:

            - Select the primary object (e.g., the forum), select the
            operation, enter a modal dialog to identify additional
            arguments

            An example of this is the print function in many applications.
            One selects an object, selects the print menu item, and a
            dialog box appears with lots of parameters/arguments to set.

            Sometimes the arguments can be set using direct manipulation
            (e.g., use the mouse to toggle buttons, or select items in an
            option menu).  But it is rarely possible to point at something
            outside the dialog box and say "that is the 'value' for this
            parameter/argument"  [okay, there is "quick-copy" of textual
            data].

            And the problems of modal interfaces are pretty well
            documented.  I personally dislike them except in the most
            straightforward cases (like "Are you sure you want to crash the
            system? o Yes  o No")

	Multi-selection + inference:

            - Select multiple objects (e.g, a Notes Conference, a mail
            message, and a distribution list), select the operation --
            object attributes (e.g., object type) are used to assign each
            selected object to an argument slot

            Unfortunately, the mapping of objects to argument slots is
	    often ambiguous.

	Modal selection:

            - Select the operation, enter "select X (e.g., forum)" mode,
            select object, enter "select Y" mode, etc., until all arguments
            are identified

            HyperCard linking uses this approach, and is a good example of
            some of the problems with modal interfaces.

	Environment state:

            - Select an object (e.g., forum), select operation "remember
            this as X (e.g., 'Set Discussion Forum')", select another
            object, select operation "remember this Y", etc. until all
            arguments have been "set", then select the main operation.

	    MEMEX and Intermedia linking used this approach (e.g., Set
	    Source, Set Target, Connect).

            This approach causes an explosion of the number of "operations"
            (an operation with n arguments becomes n+1 operations).

	Drag and Drop:

            - Drag one object (e.g., a document) over another object (e.g.,
            a Wastebasket icon) and drop it there -- object attributes
            (e.g., object type) are used to select the operation.

            Of course, this only works well for operations with 2
            arguments, and the determination of what the operation should
	    be is often difficult.

	Combinations of the above:

            - I recall seeing a combination of the modal dialog plus state
            technique used in Owl/Trellis.  For some of its multi-argument
            operations, the dialog box contained a toggle button for each
            argument.  They where initially off.  One could select an
            object, then select a toggle button.  This indicated that the
            selected object was the value of the given argument.  I suppose
            some sort of drag-and-drop technique could have been used as
            well (drag an object onto the appropriate toggle in the dialog
            box).

    Does anyone know of other approaches?  Would anyone care to discuss the
    relative merits of the various approaches?