Examples with IWidget edu.cmu.cs.hcii.cogtool.model.IWidget used on opensource projects

Example 61 with IWidget

use of edu.cmu.cs.hcii.cogtool.model.IWidget in project cogtool by cogtool.

the class FrameEditorController method duplicateGroupMember.

// Assumes that widget is an instance of MenuHeader, ListItem, or
// GridButton
private IWidget duplicateGroupMember(IWidget widget, FrameEditorSelectionState selection, double moveByX, double moveByY) {
    SimpleWidgetGroup existingGroup = widget.getParentGroup();
    SimpleWidgetGroup newGroup = widgetSituator.getGroup(existingGroup);
    // If the first time this group has been seen, populate.
    if (newGroup.size() == 0) {
        Iterator<IWidget> widgets = sortSelectedMbrs(existingGroup, selection);
        while (widgets.hasNext()) {
            Frame.duplicateWidget(widgets.next(), lookupFrameDuplicator, widgetSituator, moveByX, moveByY);
        }
        DesignEditorCmd.repositionChildren(newGroup);
    }
    return widgetSituator.getDuplicate(widget);
}

Example 62 with IWidget

use of edu.cmu.cs.hcii.cogtool.model.IWidget in project cogtool by cogtool.

the class FrameEditorController method addChildWidgets.

private void addChildWidgets(SimpleWidgetGroup widgetGroup, IUndoableEditSequence editSeq) {
    if (widgetGroup != null) {
        Iterator<IWidget> children = widgetGroup.iterator();
        while (children.hasNext()) {
            IWidget child = children.next();
            makeWidgetNameUnique(child);
            editSeq.addEdit(addWidget(child));
            if (child instanceof MenuItem) {
                MenuItem item = (MenuItem) child;
                if (item.isSubmenu()) {
                    addChildWidgets(item.getChildren(), editSeq);
                }
            }
        }
    }
}

Example 63 with IWidget

use of edu.cmu.cs.hcii.cogtool.model.IWidget in project cogtool by cogtool.

the class FrameEditorController method assignActions.

/**
     * Add the listeners for Menu Items, and other LID listeners
     */
@Override
public void assignActions() {
    // get the default actions from Default controller
    super.assignActions();
    // Enable undo & redo
    ui.setAction(FrameEditorLID.Undo, new UndoController.UndoAction(undoMgr, interaction));
    ui.setAction(FrameEditorLID.Redo, new UndoController.RedoAction(undoMgr, interaction));
    // Enable cut copy and paste
    ui.setAction(FrameEditorLID.Paste, createPasteAction());
    ui.setAction(FrameEditorLID.SetFrameTemplate, createSetFrameTemplateAction());
    ui.setAction(FrameEditorLID.ClearFrameTemplate, new AListenerAction() {

        public boolean performAction(Object prms) {
            FrameTemplateSupport.clearFrameTemplate(design);
            return true;
        }
    });
    ui.setAction(FrameEditorLID.Copy, createCopyWidgetAction());
    ui.setAction(FrameEditorLID.Cut, createCutWidgetAction());
    ui.setAction(CogToolLID.CopyPath, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState seln = (FrameEditorSelectionState) prms;
            if (seln.getWidgetSelectionCount() != 1) {
                return false;
            }
            IWidget w = seln.getSelectedIWidgets()[0];
            Object pathObj = w.getAttribute(WidgetAttributes.IMAGE_PATH_ATTR);
            if (!NullSafe.equals(WidgetAttributes.NO_IMAGE, pathObj)) {
                ClipboardUtil.copyTextData((String) pathObj);
            }
            return true;
        }
    });
    ui.setAction(FrameEditorLID.Rename, createInitiateRenameAction());
    ui.setAction(FrameEditorLID.Relabel, createInitiateRelabelAction());
    // Select all.
    ui.setAction(FrameEditorLID.SelectAll, new AListenerAction() {

        public boolean performAction(Object prms) {
            ui.selectAllWidgets();
            return true;
        }
    });
    // Creating a new widget
    // May be called from the menu item, or from mouseState
    ui.setAction(FrameEditorLID.NewWidget, createNewWidgetAction());
    ui.setAction(FrameEditorLID.NewWidgetJustWarn, createNewWidgetExplanationAction());
    // Delete an item.
    // Requires a selection state
    ui.setAction(FrameEditorLID.Delete, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Delete the item / add undo
            return deleteElements(selection);
        }
    });
    // Adjust image/color properties
    ui.setAction(FrameEditorLID.SetBackgroundImage, createSetBackgroundImageAction());
    // Clear the background of an image.
    ui.setAction(FrameEditorLID.RemoveBackgroundImage, new AListenerAction() {

        public boolean performAction(Object prms) {
            // Clear background, by saying use
            // "no" image.
            setBackgroundImage(null, WidgetAttributes.NO_IMAGE);
            return true;
        }
    });
    ui.setAction(FrameEditorLID.CopyImageAsBackground, createCopyImageAsBkgAction());
    ui.setAction(FrameEditorLID.PasteBackgroundImage, createPasteBackgroundImageAction());
    // Set the color of the widgets.
    ui.setAction(FrameEditorLID.SetWidgetColor, newSetWidgetColorAction());
    // Skins!
    ui.setAction(FrameEditorLID.SkinWireFrame, createSetSkinAction(SkinType.WireFrame, FrameEditorLID.SkinWireFrame));
    ui.setAction(FrameEditorLID.SkinMacOSX, createSetSkinAction(SkinType.MacOSX, FrameEditorLID.SkinMacOSX));
    ui.setAction(FrameEditorLID.SkinWinXP, createSetSkinAction(SkinType.WinXP, FrameEditorLID.SkinWinXP));
    ui.setAction(FrameEditorLID.SkinPalm, createSetSkinAction(SkinType.Palm, FrameEditorLID.SkinPalm));
    ui.setAction(CogToolLID.RenderAll, createRenderAllAction(true, CogToolLID.RenderAll));
    ui.setAction(CogToolLID.UnRender, createRenderAllAction(false, CogToolLID.UnRender));
    // Nudge selected widget(s)
    // requires selection
    ui.setAction(FrameEditorLID.NudgeLeft, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Displace left by 1 pixel scaled by
            // the zoom
            double dx = -1.0 / ui.getZoom();
            // Move by the point
            return moveElements(selection, dx, 0.0);
        }
    });
    ui.setAction(FrameEditorLID.NudgeRight, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Move by 1 pixel scaled by zoom right.
            double dx = 1.0 / ui.getZoom();
            return moveElements(selection, dx, 0.0);
        }
    });
    ui.setAction(FrameEditorLID.NudgeUp, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Move up 1 pixel scaled by zoom
            double dy = -1.0 / ui.getZoom();
            return moveElements(selection, 0.0, dy);
        }
    });
    ui.setAction(FrameEditorLID.NudgeDown, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // move down by 1 pixel scaled by zoom
            double dy = 1.0 / ui.getZoom();
            return moveElements(selection, 0.0, dy);
        }
    });
    // Align selected widgets
    ui.setAction(FrameEditorLID.AlignTop, new ElementAlignmentAction(AlignmentAction.TOP));
    ui.setAction(FrameEditorLID.AlignBottom, new ElementAlignmentAction(AlignmentAction.BOTTOM));
    ui.setAction(FrameEditorLID.AlignLeft, new ElementAlignmentAction(AlignmentAction.LEFT));
    ui.setAction(FrameEditorLID.AlignRight, new ElementAlignmentAction(AlignmentAction.RIGHT));
    ui.setAction(FrameEditorLID.AlignCenter, new ElementAlignmentAction(AlignmentAction.CENTER));
    ui.setAction(FrameEditorLID.AlignHorizCenter, new ElementAlignmentAction(AlignmentAction.HORIZ_CENTER));
    ui.setAction(FrameEditorLID.AlignVertCenter, new ElementAlignmentAction(AlignmentAction.VERT_CENTER));
    // Space selected widgets equally
    ui.setAction(FrameEditorLID.SpaceVertically, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Equally space the widgets in the
            // vertical axis.
            final boolean VERTICAL = true;
            return spaceElementsEqually(selection, VERTICAL);
        }
    });
    ui.setAction(FrameEditorLID.SpaceHorizontally, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Equally space the widgets in the
            // horizontal axis.
            final boolean HORIZONTAL = false;
            return spaceElementsEqually(selection, HORIZONTAL);
        }
    });
    // Adjust ordering of selected widget(s)
    ui.setAction(FrameEditorLID.BringToFront, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            CompoundUndoableEdit editSequence = new CompoundUndoableEdit(BRING_TO_FRONT, FrameEditorLID.BringToFront);
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Get the list of selected widgets
            // Keep them in the same level ordering
            // they started in
            IWidget[] selected = getSelectedWidgets(selection, Widget.WidgetLevelComparator.ONLY);
            // set the level.
            for (IWidget element : selected) {
                // use MAX Value here
                // adjustWidgetLevel will tell the frame
                // and it will change MAX_VALUE to
                // be the correct number
                adjustWidgetLevel(Integer.MAX_VALUE, element, editSequence, editSequence.getLID());
            }
            editSequence.end();
            // Only add this edit if it is significant
            if (editSequence.isSignificant()) {
                undoMgr.addEdit(editSequence);
            }
            return true;
        }
    });
    ui.setAction(FrameEditorLID.BringForward, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            CompoundUndoableEdit editSequence = new CompoundUndoableEdit(BRING_FORWARD, FrameEditorLID.BringForward);
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Get the list of selected widgets
            // Keep them in the same level ordering
            // they started in
            IWidget[] selected = getSelectedWidgets(selection, Widget.WidgetLevelComparator.ONLY);
            // Fix corner case where all the widgets are
            // stacked downward from the top
            // IE: Prevent the current top most item
            // from moving.
            int maxLevel = model.getWidgets().size() - 1;
            // Traverse the list sorted by level in reverse order
            for (int i = selected.length - 1; i >= 0; i--, maxLevel--) {
                IWidget w = selected[i];
                int widgetLevel = w.getLevel();
                // try to increase it one.
                if (widgetLevel < maxLevel) {
                    adjustWidgetLevel(widgetLevel + 1, w, editSequence, editSequence.getLID());
                }
            }
            editSequence.end();
            // Only add this edit if it is significant
            if (editSequence.isSignificant()) {
                undoMgr.addEdit(editSequence);
            }
            return true;
        }
    });
    ui.setAction(FrameEditorLID.SendBackward, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            CompoundUndoableEdit editSequence = new CompoundUndoableEdit(SEND_BACKWARD, FrameEditorLID.SendBackward);
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Get the list of selected widgets
            // Keep them in the same level ordering
            // they started in
            IWidget[] selected = getSelectedWidgets(selection, Widget.WidgetLevelComparator.ONLY);
            // Fix corner case where all the widgets are
            // stacked upward from level 0
            int minLevel = 0;
            for (int i = 0; i < selected.length; i++, minLevel++) {
                IWidget w = selected[i];
                int widgetLevel = w.getLevel();
                // move the level down by 1
                if (widgetLevel > minLevel) {
                    adjustWidgetLevel(widgetLevel - 1, w, editSequence, editSequence.getLID());
                }
            }
            editSequence.end();
            // Only add this edit if it is significant
            if (editSequence.isSignificant()) {
                undoMgr.addEdit(editSequence);
            }
            return true;
        }
    });
    ui.setAction(FrameEditorLID.SendToBack, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            CompoundUndoableEdit editSequence = new CompoundUndoableEdit(SEND_TO_BACK, FrameEditorLID.SendToBack);
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Get the list of selected widgets
            // Keep them in the same level ordering
            // they started in
            IWidget[] selected = getSelectedWidgets(selection, Widget.WidgetLevelComparator.ONLY);
            // in the correct order
            for (int i = selected.length - 1; i >= 0; i--) {
                // try to move all towards 0.
                adjustWidgetLevel(0, selected[i], editSequence, editSequence.getLID());
            }
            editSequence.end();
            // Only add this edit if it is significant
            if (editSequence.isSignificant()) {
                undoMgr.addEdit(editSequence);
            }
            return true;
        }
    });
    // Mouse operations on widgets
    ui.setAction(FrameEditorLID.MoveWidgets, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.MoveParameters.class;
        }

        public boolean performAction(Object prms) {
            // Get the move parameters.
            FrameEditorUI.MoveParameters movePrms = (FrameEditorUI.MoveParameters) prms;
            if (movePrms != null) {
                return moveElements(movePrms.selection, movePrms.moveByX, movePrms.moveByY, movePrms.moveAsGroup);
            }
            return false;
        }
    });
    ui.setAction(FrameEditorLID.Reorder, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.ReorderWidgetParameters.class;
        }

        public boolean performAction(Object prms) {
            // Get the parameters.
            FrameEditorUI.ReorderWidgetParameters rPrms = (FrameEditorUI.ReorderWidgetParameters) prms;
            if (rPrms != null) {
                if (rPrms.parent == null) {
                    return reorderWidget(rPrms.reorderWidget, rPrms.widgetGroup, rPrms.insertIndex);
                }
                return reorderChildWidget((ChildWidget) rPrms.reorderWidget, rPrms.widgetGroup, rPrms.insertIndex, rPrms.parent);
            }
            return false;
        }
    });
    ui.setAction(FrameEditorLID.InsertDuplicate, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.InsertDuplicateParameters.class;
        }

        public boolean performAction(Object prms) {
            // Get the parameters.
            FrameEditorUI.InsertDuplicateParameters iPrms = (FrameEditorUI.InsertDuplicateParameters) prms;
            if (iPrms != null) {
                return insertDuplicateWidget(iPrms.reorderWidget, iPrms.widgetGroup, iPrms.insertIndex, iPrms.parent, iPrms.moveByX, iPrms.moveByY);
            }
            return false;
        }
    });
    ui.setAction(FrameEditorLID.ResizeWidgets, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.ResizeParameters.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorUI.ResizeParameters resizePrms = (FrameEditorUI.ResizeParameters) prms;
            if (prms != null) {
                // Resize the frame elements based on prms
                return resizeElements(resizePrms.oldX, resizePrms.oldY, resizePrms.newX, resizePrms.newY, resizePrms.ratioX, resizePrms.ratioY, resizePrms.selection);
            }
            return false;
        }
    });
    // Change properties of selected widget(s)
    ui.setAction(FrameEditorLID.ChangeShapeProperty, createChangeShapeAction());
    // Change the widget title.
    // The title is non unique.
    ui.setAction(FrameEditorLID.ChangeTitleProperty, createChangeTitlePropertyAction());
    ui.setAction(FrameEditorLID.ChangeAuxTextProperty, createChangeAuxTextPropertyAction());
    // Change the name. This requires a UNIQUE name.
    // Only one selected widget is expected.
    ui.setAction(DesignEditorLID.RenameFrame, new IListenerAction() {

        public Class<?> getParameterClass() {
            return DesignEditorUI.FrameRenameParameters.class;
        }

        public boolean performAction(Object prms) {
            DesignEditorUI.FrameRenameParameters p = (DesignEditorUI.FrameRenameParameters) prms;
            return updateFrameName(p.frame, p.newName);
        }
    });
    // Change the name. This requires a UNIQUE name.
    // Only one selected widget is expected.
    ui.setAction(FrameEditorLID.ChangeNameProperty, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.ActionStringParameters.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorUI.ActionStringParameters p = (FrameEditorUI.ActionStringParameters) prms;
            // Check selection count
            int numWidgets = p.selection.getWidgetSelectionCount();
            if (numWidgets == 0) {
                interaction.protestNoSelection();
            } else if (numWidgets > 1) {
                interaction.protestTooManyWidgets();
            } else {
                IWidget[] selectedWidget = p.selection.getSelectedIWidgets();
                // Update widget's name
                return updateWidgetName(selectedWidget[0], p.newString);
            }
            return false;
        }
    });
    // Change the type of the widget.
    // TODO: this needs to be extended to invalidate transitions (e.g., if changed to Noninteractive)
    ui.setAction(FrameEditorLID.ChangeTypeProperty, createChangeTypeAction());
    ui.setAction(FrameEditorLID.SetRenderSkin, createSetRenderSkinAction());
    // Set the widget image property.
    ui.setAction(FrameEditorLID.SetImageProperty, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            // Apply to all selected items.
            Iterator<IWidget> selected = selection.getSelectedWidgetsIterator();
            // Prompt user for the new file
            String imageURL = interaction.selectImageFile();
            // Check if the user canceled the dialog
            if (imageURL != null) {
                try {
                    byte[] imageData = GraphicsUtil.loadImageFromFile(imageURL);
                    setWidgetImages(selected, imageData, imageURL);
                    return true;
                } catch (IOException e) {
                    // Tell the user if there was a
                    // problem reading the file.
                    interaction.protestUnreadableFile();
                }
            }
            return false;
        }
    });
    // Clear the image stored on a widget.
    ui.setAction(FrameEditorLID.RemoveImageProperty, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorSelectionState.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorSelectionState selection = (FrameEditorSelectionState) prms;
            Iterator<IWidget> selected = selection.getSelectedWidgetsIterator();
            // Remove all the images
            setWidgetImages(selected, null, WidgetAttributes.NO_IMAGE);
            return true;
        }
    });
    // capture the image under a widget..
    // IE: get its background.
    ui.setAction(FrameEditorLID.CaptureImageProperty, captureImageAction());
    ui.setAction(FrameEditorLID.Duplicate, duplicateWidgetsAction());
    ui.setAction(CogToolLID.SetAttribute, new IListenerAction() {

        public Class<?> getParameterClass() {
            return UI.SetAttributeParameters.class;
        }

        public boolean performAction(Object prms) {
            UI.SetAttributeParameters saprms = (UI.SetAttributeParameters) prms;
            return frameSetAttribute(saprms.target, saprms.attrName, saprms.value, undoMgr);
        }
    });
    ui.setAction(FrameEditorLID.SetSpeakerText, new IListenerAction() {

        public Class<?> getParameterClass() {
            return String.class;
        }

        public boolean performAction(Object prms) {
            return setSpeakerText((String) prms);
        }
    });
    ui.setAction(FrameEditorLID.SetSpeakerTime, new IListenerAction() {

        public Class<?> getParameterClass() {
            return Double.class;
        }

        public boolean performAction(Object prms) {
            double newTime = ((Double) prms).doubleValue();
            return setSpeakerDuration(newTime);
        }
    });
    ui.setAction(FrameEditorLID.AddDesignDevices, new AListenerAction() {

        public boolean performAction(Object prms) {
            return DesignCmd.addDevices(project, design, interaction);
        }
    });
    ui.setAction(FrameEditorLID.Group, createGroupElementsAction());
    ui.setAction(FrameEditorLID.Ungroup, createUngroupElementsAction());
    ui.setAction(FrameEditorLID.RenameEltGroup, new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.EltGroupRenameParameters.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorUI.EltGroupRenameParameters p = (FrameEditorUI.EltGroupRenameParameters) prms;
            return renameEltGroup(p.eltGroup, p.newName);
        }
    });
    ui.setAction(FrameEditorLID.SetRemoteLabelText, createSetRemoteLabelTextAction());
    ui.setAction(FrameEditorLID.SetRemoteLabelType, createSetRemoteLabelTypeAction());
}

Example 64 with IWidget

use of edu.cmu.cs.hcii.cogtool.model.IWidget in project cogtool by cogtool.

the class FrameEditorController method createChangeTypeAction.

/**
     * Create a listener action for changing the type.
     * Changing the type can be a dangerous option.
     * If you change the type and thus change what kind of
     * transition you can use, it may play havoc on scripts, and design view.
     * @return
     */
private IListenerAction createChangeTypeAction() {
    return new IListenerAction() {

        public Class<?> getParameterClass() {
            return FrameEditorUI.TypeChangeParameters.class;
        }

        public boolean performAction(Object prms) {
            FrameEditorUI.TypeChangeParameters p = (FrameEditorUI.TypeChangeParameters) prms;
            Iterator<IWidget> selected = p.selection.getSelectedWidgetsIterator();
            CompoundUndoableEdit editSequence = new CompoundUndoableEdit(CHG_WIDGET_TYPE, FrameEditorLID.ChangeTypeProperty);
            while (selected.hasNext()) {
                IWidget widget = selected.next();
                // Check if the widget types match
                // TODO: deal with the following
                // WidgetType.compatibleTransitions(oldWidgetType,
                //                                  p.newWidgetType)
                // if it returns false, show interaction..
                // auto delete transition?
                changeWidgetType(FrameEditorLID.ChangeTypeProperty, CHG_WIDGET_TYPE, widget, p.newWidgetType, editSequence);
            }
            editSequence.end();
            // Don't add empty edits!
            if (editSequence.isSignificant()) {
                undoMgr.addEdit(editSequence);
            }
            return true;
        }
    };
}

Example 65 with IWidget

use of edu.cmu.cs.hcii.cogtool.model.IWidget in project cogtool by cogtool.

the class FrameEditorController method spaceElementsEqually.

/**
     * Spaces the selected frame elements equally along a certain axis
     * @param vertical true for vertical axis; false for horizontal
     */
private boolean spaceElementsEqually(FrameEditorSelectionState selection, boolean vertical) {
    // Order the widgets according to location
    // (either from the left or from the top)
    Comparator<FrameElement> c = vertical ? elementVerticalComparator : elementHorizontalComparator;
    Set<FrameElement> elements = getSelectedElements(selection, c);
    if (elements.size() <= 2) {
        interaction.protestTooFewElements();
        return false;
    }
    // Calculate the spacing between widgets
    double sum = 0;
    double min = Double.MAX_VALUE;
    double max = Double.MIN_VALUE;
    // Go through each element that is selected
    // Determine the size, min & max of the region.
    // this can then be used to do spacing.
    Iterator<FrameElement> eltIter = elements.iterator();
    while (eltIter.hasNext()) {
        DoubleRectangle bounds = eltIter.next().getEltBounds();
        double size = vertical ? bounds.height : bounds.width;
        double position = vertical ? bounds.y : bounds.x;
        sum += size;
        min = Math.min(min, position);
        max = Math.max(max, size + position);
    }
    // Get the spacing to use between each item.
    double spacing = ((max - min) - sum) / (elements.size() - 1);
    String undoRedoLabel = vertical ? SPACE_VERTICALLY : SPACE_HORIZONTALLY;
    CogToolLID lid = vertical ? FrameEditorLID.SpaceVertically : FrameEditorLID.SpaceHorizontally;
    CompoundUndoableEdit editSequence = new CompoundUndoableEdit(undoRedoLabel, lid);
    // Avoid moving a group more than once
    Set<SimpleWidgetGroup> movedGroups = new HashSet<SimpleWidgetGroup>();
    Set<IWidget> movedWidgets = new HashSet<IWidget>();
    // Adjust the spacings to the correct values and go through
    // each element performing the appropriate move.
    eltIter = elements.iterator();
    while (eltIter.hasNext()) {
        FrameElement elt = eltIter.next();
        DoubleRectangle bounds = elt.getEltBounds();
        // Determine the amount to move each element
        double deltaX = vertical ? 0.0 : (min - bounds.x);
        double deltaY = vertical ? (min - bounds.y) : 0.0;
        // Set the new location, adding the undoable edit
        moveElement(lid, undoRedoLabel, elt, deltaX, deltaY, true, movedGroups, movedWidgets, editSequence);
        // Advance the pointer to the next location
        min += spacing + (vertical ? bounds.height : bounds.width);
    }
    editSequence.end();
    // Only add this edit if it is significant
    if (editSequence.isSignificant()) {
        undoMgr.addEdit(editSequence);
    }
    return true;
}