Examples with IListenerAction edu.cmu.cs.hcii.cogtool.util.IListenerAction used on opensource projects

Example 61 with IListenerAction

use of edu.cmu.cs.hcii.cogtool.util.IListenerAction in project cogtool by cogtool.

the class FrameEditorController method duplicateWidgetsAction.

// duplicateFrameEltGroup
private IListenerAction duplicateWidgetsAction() {
    return new IListenerAction() {

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

        public boolean performAction(Object prms) {
            FrameEditorUI.DuplicateParameters parameters = (FrameEditorUI.DuplicateParameters) prms;
            int elementCount = parameters.selection.getElementSelectionCount();
            // If selection is non zero, copy widgets
            if (elementCount > 0) {
                Map<IWidget, IWidget> widgetCopies = new LinkedHashMap<IWidget, IWidget>();
                final Map<FrameElementGroup, FrameElementGroup> groupCopies = new LinkedHashMap<FrameElementGroup, FrameElementGroup>();
                widgetSituator.reset(widgetCopies, groupCopies);
                Set<FrameElement> selectedElements = getSelectedElements(parameters.selection, elementLevelComparator);
                Iterator<FrameElement> elements = selectedElements.iterator();
                // Iterate through the widgets and duplicate.
                while (elements.hasNext()) {
                    FrameElement elt = elements.next();
                    if (elt instanceof IWidget) {
                        duplicateWidget((IWidget) elt, parameters.selection, parameters.moveByX, parameters.moveByY);
                    } else if (elt instanceof FrameElementGroup) {
                        duplicateFrameEltGroup((FrameElementGroup) elt, parameters.moveByX, parameters.moveByY);
                    }
                }
                widgetSituator.completeWork();
                final Iterable<? extends IWidget> widgetDuplicates = new ReadOnlyList<IWidget>(new ArrayList<IWidget>(widgetCopies.values()));
                Iterator<? extends IWidget> copiedWidgets = widgetDuplicates.iterator();
                Set<GridButtonGroup> dupGridGroups = new HashSet<GridButtonGroup>();
                while (copiedWidgets.hasNext()) {
                    IWidget widgetCopy = copiedWidgets.next();
                    // Warning: it is important that each widget be added
                    // to the frame *before* we make the next widget name
                    // unique or we can end up with non-unique names.
                    makeWidgetNameUnique(widgetCopy);
                    model.addWidget(widgetCopy);
                    if (widgetCopy instanceof GridButton) {
                        GridButtonGroup gbg = (GridButtonGroup) widgetCopy.getParentGroup();
                        // for each grid button group
                        if (!dupGridGroups.contains(gbg)) {
                            gbg.recalculateOffsets();
                            dupGridGroups.add(gbg);
                        }
                    }
                }
                Iterator<FrameElementGroup> copiedGroups = groupCopies.values().iterator();
                while (copiedGroups.hasNext()) {
                    FrameElementGroup copiedGroup = copiedGroups.next();
                    // Ensure name is unique, then add to frame immediately
                    // Otherwise, it would be possible to generate presumed
                    // unique names that weren't.
                    makeEltGroupNameUnique(copiedGroup);
                    model.addEltGroup(copiedGroup);
                }
                DemoStateManager.IDesignUndoableEdit edit = new DemoStateManager.InvalidatingEdit(FrameEditorLID.Duplicate, demoStateMgr) {

                    @Override
                    public String getPresentationName() {
                        return DUPLICATE_WIDGETS;
                    }

                    @Override
                    public void redo() {
                        super.redo();
                        Iterator<? extends IWidget> addCopies = widgetDuplicates.iterator();
                        while (addCopies.hasNext()) {
                            IWidget widgetCopy = addCopies.next();
                            model.addWidget(widgetCopy);
                        }
                        Iterator<FrameElementGroup> copiedGroups = groupCopies.values().iterator();
                        while (copiedGroups.hasNext()) {
                            model.addEltGroup(copiedGroups.next());
                        }
                        demoStateMgr.noteWidgetsEdit(widgetDuplicates, this);
                    }

                    @Override
                    public void undo() {
                        super.undo();
                        Iterator<? extends IWidget> removeCopies = widgetDuplicates.iterator();
                        while (removeCopies.hasNext()) {
                            IWidget widgetCopy = removeCopies.next();
                            model.removeWidget(widgetCopy);
                        }
                        Iterator<FrameElementGroup> copiedGroups = groupCopies.values().iterator();
                        while (copiedGroups.hasNext()) {
                            model.removeEltGroup(copiedGroups.next());
                        }
                        demoStateMgr.noteWidgetsEdit(widgetDuplicates, this);
                    }
                };
                demoStateMgr.noteWidgetsEdit(widgetDuplicates, edit);
                undoMgr.addEdit(edit);
                return true;
            }
            // tell user to select something.
            interaction.protestNoSelection();
            return false;
        }
    };
}

Example 62 with IListenerAction

use of edu.cmu.cs.hcii.cogtool.util.IListenerAction in project cogtool by cogtool.

the class FrameEditorController method createSetFrameTemplateAction.

/**
     * Record the Widgets in the clipboard as the template to use
     * when creating new Frames.
     */
private IListenerAction createSetFrameTemplateAction() {
    return new IListenerAction() {

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

        public boolean performAction(Object prms) {
            FrameEditorSelectionState seln = (FrameEditorSelectionState) prms;
            // If selection is non zero, copy widgets
            if (seln.getElementSelectionCount() > 0) {
                copyElements(seln, DesignEditorCmd.SAVE_TO_TEMPLATE);
                interaction.setStatusMessage(templateCreated);
                return true;
            }
            // tell user to select something.
            interaction.setStatusMessage(noTemplateWidgets);
            interaction.protestNoSelection();
            return false;
        }
    };
}

Example 63 with IListenerAction

use of edu.cmu.cs.hcii.cogtool.util.IListenerAction 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 IListenerAction

use of edu.cmu.cs.hcii.cogtool.util.IListenerAction in project cogtool by cogtool.

the class ProjectController method createAddDesignDevicesAction.

// createNewDesignAction2
protected IListenerAction createAddDesignDevicesAction() {
    return new IListenerAction() {

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

        public boolean performAction(Object prms) {
            DesignSelectionState selection = (DesignSelectionState) prms;
            Design design = selection.getSelectedDesign();
            if (design != null) {
                return DesignCmd.addDevices(project, design, interaction);
            }
            interaction.protestNoSelection();
            return true;
        }
    };
}

Example 65 with IListenerAction

use of edu.cmu.cs.hcii.cogtool.util.IListenerAction in project cogtool by cogtool.

the class ProjectController method createDuplicateTaskAppAction.

protected IListenerAction createDuplicateTaskAppAction() {
    return new IListenerAction() {

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

        public boolean performAction(Object p) {
            if (p != null) {
                ProjectUI.MoveCopyTaskApplicationParms parms = (ProjectUI.MoveCopyTaskApplicationParms) p;
                // Must have selected tasks and design
                if ((parms.design == null) || (parms.fromTask == null) || (parms.toTask == null)) {
                    interaction.protestNoSelection();
                    return false;
                }
                final AUndertaking fromTask = parms.fromTask;
                final AUndertaking toTask = parms.toTask;
                TaskApplication taskApp = project.getTaskApplication(fromTask, parms.design);
                if (taskApp == null) {
                    interaction.protestNoTaskApplication();
                    return false;
                }
                final TaskApplication oldTaskApp = project.removeTaskApplication(parms.toTask, parms.design);
                final TaskApplication newTaskApp = taskApp.duplicate(toTask, parms.design);
                DemoStateManager demoMgr = DemoStateManager.getStateManager(project, parms.design);
                project.setTaskApplication(newTaskApp);
                demoMgr.trackEdits(newTaskApp.getDemonstration());
                IUndoableEdit edit = new AUndoableEdit(ProjectLID.DuplicateTaskApplication) {

                    protected boolean recoverMgrs = false;

                    @Override
                    public String getPresentationName() {
                        return DUPLICATE_TASKAPP;
                    }

                    @Override
                    public void redo() {
                        super.redo();
                        if (oldTaskApp != null) {
                            project.removeTaskApplication(oldTaskApp);
                        }
                        project.setTaskApplication(newTaskApp);
                        recoverMgrs = false;
                    }

                    @Override
                    public void undo() {
                        super.undo();
                        project.removeTaskApplication(newTaskApp);
                        if (oldTaskApp != null) {
                            project.setTaskApplication(oldTaskApp);
                        }
                        recoverMgrs = true;
                    }

                    @Override
                    public void die() {
                        if (recoverMgrs) {
                            recoverManagers(newTaskApp);
                        }
                    }
                };
                undoMgr.addEdit(edit);
            }
            return true;
        }
    };
}