/*******************************************************************************
* Copyright (c) 2011, 2012 Formal Mind GmbH and University of Dusseldorf.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Lukas Ladenberger - initial API and implementation
******************************************************************************/
package org.eclipse.rmf.reqif10.pror.editor.agilegrid;
import java.beans.PropertyChangeListener;
import org.agilemore.agilegrid.CellEditor;
import org.eclipse.emf.edit.ui.EMFEditUIPlugin;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
/**
* <p>
* Handles the redirection of the global actions Cut, Copy, Paste, Delete,
* Select All, Find, Undo and Redo to either the current activated agile grid
* cell editor or the specification editor's supplied action handler (EMF
* specific actions).
* </p>
* <p>
* This class may be instantiated; it is not intended to be subclassed.
* </p>
*/
public class AgileCellEditorActionHandler {
private final ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
private CutActionHandler cellCutAction = new CutActionHandler();
private CopyActionHandler cellCopyAction = new CopyActionHandler();
private PasteActionHandler cellPasteAction = new PasteActionHandler();
private DeleteActionHandler cellDeleteAction = new DeleteActionHandler();
private SelectAllActionHandler cellSelectAllAction = new SelectAllActionHandler();
private FindActionHandler cellFindAction = new FindActionHandler();
private UndoActionHandler cellUndoAction = new UndoActionHandler();
private RedoActionHandler cellRedoAction = new RedoActionHandler();
private IAction cutAction;
private IAction copyAction;
private IAction pasteAction;
private IAction deleteAction;
private IAction selectAllAction;
private IAction findAction;
private IAction undoAction;
private IAction redoAction;
private IPropertyChangeListener cutActionListener = new ActionEnabledChangeListener(
cellCutAction);
private IPropertyChangeListener copyActionListener = new ActionEnabledChangeListener(
cellCopyAction);
private IPropertyChangeListener pasteActionListener = new ActionEnabledChangeListener(
cellPasteAction);
private IPropertyChangeListener deleteActionListener = new ActionEnabledChangeListener(
cellDeleteAction);
private IPropertyChangeListener selectAllActionListener = new ActionEnabledChangeListener(
cellSelectAllAction);
private IPropertyChangeListener findActionListener = new ActionEnabledChangeListener(
cellFindAction);
private IPropertyChangeListener undoActionListener = new ActionEnabledChangeListener(
cellUndoAction);
private IPropertyChangeListener redoActionListener = new ActionEnabledChangeListener(
cellRedoAction);
private CellEditor activeEditor;
private PropertyChangeListener cellListener = new CellChangeListener();
private Listener controlListener = new ControlListener();
//private HashMap<Control,CellEditor> controlToEditor = new HashMap<Control,CellEditor>();
private class ControlListener implements Listener {
public void handleEvent(Event event) {
switch (event.type) {
case SWT.Activate:
//activeEditor = (CellEditor) controlToEditor.get(event.widget);
if (activeEditor != null) {
activeEditor.addPropertyChangeListener(cellListener);
}
updateActionsEnableState();
break;
case SWT.Deactivate:
if (activeEditor != null) {
activeEditor.removePropertyChangeListener(cellListener);
}
activeEditor = null;
updateActionsEnableState();
break;
default:
break;
}
}
}
private class ActionEnabledChangeListener implements
IPropertyChangeListener {
private IAction actionHandler;
protected ActionEnabledChangeListener(IAction actionHandler) {
super();
this.actionHandler = actionHandler;
}
public void propertyChange(PropertyChangeEvent event) {
if (activeEditor != null) {
return;
}
if (event.getProperty().equals(IAction.ENABLED)) {
Boolean bool = (Boolean) event.getNewValue();
actionHandler.setEnabled(bool.booleanValue());
return;
}
// If the underlying action's text has changed, we need to
// change the text. See
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=154410
if (event.getProperty().equals(IAction.TEXT)) {
String text = (String) event.getNewValue();
actionHandler.setText(text);
return;
}
if (event.getProperty().equals(IAction.TOOL_TIP_TEXT)) {
String text = (String) event.getNewValue();
actionHandler.setToolTipText(text);
return;
}
}
}
private class CellChangeListener implements PropertyChangeListener {
public void propertyChange(java.beans.PropertyChangeEvent event) {
if (activeEditor == null) {
return;
}
if (event.getPropertyName().equals(CellEditor.CUT)) {
cellCutAction.setEnabled(activeEditor.isCutEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.COPY)) {
cellCopyAction.setEnabled(activeEditor.isCopyEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.PASTE)) {
cellPasteAction.setEnabled(activeEditor.isPasteEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.DELETE)) {
cellDeleteAction.setEnabled(activeEditor.isDeleteEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.SELECT_ALL)) {
cellSelectAllAction.setEnabled(activeEditor
.isSelectAllEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.FIND)) {
cellFindAction.setEnabled(activeEditor.isFindEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.UNDO)) {
cellUndoAction.setEnabled(activeEditor.isUndoEnabled());
return;
}
if (event.getPropertyName().equals(CellEditor.REDO)) {
cellRedoAction.setEnabled(activeEditor.isRedoEnabled());
return;
}
}
}
private class CutActionHandler extends Action {
protected CutActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Cut_menu_item"));
setId("CellEditorCutActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
//PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_CUT_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performCut();
return;
}
if (cutAction != null) {
cutAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isCutEnabled());
return;
}
if (cutAction != null) {
setEnabled(cutAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class CopyActionHandler extends Action {
protected CopyActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Copy_menu_item"));
setId("CellEditorCopyActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages
.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
// PlatformUI.getWorkbench().getHelpSystem().setHelp(this,
// IWorkbenchHelpContextIds.CELL_COPY_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performCopy();
return;
}
if (copyAction != null) {
copyAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isCopyEnabled());
return;
}
if (copyAction != null) {
setEnabled(copyAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class PasteActionHandler extends Action {
protected PasteActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Paste_menu_item"));
setId("CellEditorPasteActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
//PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_PASTE_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performPaste();
return;
}
if (pasteAction != null) {
pasteAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isPasteEnabled());
return;
}
if (pasteAction != null) {
setEnabled(pasteAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class DeleteActionHandler extends Action {
protected DeleteActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Delete_menu_item"));
setId("CellEditorDeleteActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_DELETE));
// PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_DELETE_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performDelete();
return;
}
if (deleteAction != null) {
deleteAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isDeleteEnabled());
return;
}
if (deleteAction != null) {
setEnabled(deleteAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class SelectAllActionHandler extends Action {
protected SelectAllActionHandler() {
super("Select All");
setId("CellEditorSelectAllActionHandler");//$NON-NLS-1$
setEnabled(false);
//PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_SELECT_ALL_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performSelectAll();
return;
}
if (selectAllAction != null) {
selectAllAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isSelectAllEnabled());
return;
}
if (selectAllAction != null) {
setEnabled(selectAllAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class FindActionHandler extends Action {
protected FindActionHandler() {
setId("CellEditorFindActionHandler");//$NON-NLS-1$
setEnabled(false);
// PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_FIND_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performFind();
return;
}
if (findAction != null) {
findAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isFindEnabled());
return;
}
if (findAction != null) {
setEnabled(findAction.isEnabled());
return;
}
setEnabled(false);
}
}
private class UndoActionHandler extends Action {
protected UndoActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Undo_menu_item"));
setId("CellEditorUndoActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
//PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_UNDO_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performUndo();
return;
}
if (undoAction != null) {
undoAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isUndoEnabled());
//setText(WorkbenchMessages.Workbench_undo);
//setToolTipText(WorkbenchMessages.Workbench_undoToolTip);
return;
}
if (undoAction != null) {
setEnabled(undoAction.isEnabled());
setText(undoAction.getText());
setToolTipText(undoAction.getToolTipText());
return;
}
setEnabled(false);
}
}
private class RedoActionHandler extends Action {
protected RedoActionHandler() {
super(EMFEditUIPlugin.INSTANCE.getString("_UI_Redo_menu_item"));
setId("CellEditorRedoActionHandler");//$NON-NLS-1$
setEnabled(false);
setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
//PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IWorkbenchHelpContextIds.CELL_REDO_ACTION);
}
public void runWithEvent(Event event) {
if (activeEditor != null) {
activeEditor.performRedo();
return;
}
if (redoAction != null) {
redoAction.runWithEvent(event);
return;
}
}
public void updateEnabledState() {
if (activeEditor != null) {
setEnabled(activeEditor.isRedoEnabled());
//setText(WorkbenchMessages.Workbench_redo);
// setToolTipText(WorkbenchMessages.Workbench_redoToolTip);
return;
}
if (redoAction != null) {
setEnabled(redoAction.isEnabled());
setText(redoAction.getText());
setToolTipText(redoAction.getToolTipText());
return;
}
setEnabled(false);
}
}
/**
* Creates a <code>CellEditor</code> action handler
* for the global Cut, Copy, Paste, Delete, Select All,
* Find, Undo, and Redo of the action bar.
*
* @param actionBar the action bar to register global
* action handlers.
*/
public AgileCellEditorActionHandler(IActionBars actionBar) {
super();
actionBar.setGlobalActionHandler(ActionFactory.CUT.getId(),
cellCutAction);
actionBar.setGlobalActionHandler(ActionFactory.COPY.getId(),
cellCopyAction);
actionBar.setGlobalActionHandler(ActionFactory.PASTE.getId(),
cellPasteAction);
actionBar.setGlobalActionHandler(ActionFactory.DELETE.getId(),
cellDeleteAction);
actionBar.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(),
cellSelectAllAction);
actionBar.setGlobalActionHandler(ActionFactory.FIND.getId(),
cellFindAction);
actionBar.setGlobalActionHandler(ActionFactory.UNDO.getId(),
cellUndoAction);
actionBar.setGlobalActionHandler(ActionFactory.REDO.getId(),
cellRedoAction);
}
// /**
// * Adds a <code>CellEditor</code> to the handler so that the
// * Cut, Copy, Paste, Delete, Select All, Find, Undo, and Redo
// * actions are redirected to it when active.
// *
// * @param editor the <code>CellEditor</code>
// */
// public void addCellEditor(CellEditor editor) {
// if (editor == null) {
// return;
// }
//
// Control control = editor.getControl();
// Assert.isNotNull(control);
// controlToEditor.put(control, editor);
// control.addListener(SWT.Activate, controlListener);
// control.addListener(SWT.Deactivate, controlListener);
//
// if (control.isFocusControl()) {
// activeEditor = editor;
// editor.addPropertyChangeListener(cellListener);
// updateActionsEnableState();
// }
// }
/**
* Disposes of this action handler
*/
public void dispose() {
setCutAction(null);
setCopyAction(null);
setPasteAction(null);
setDeleteAction(null);
setSelectAllAction(null);
setFindAction(null);
setUndoAction(null);
setRedoAction(null);
// Iterator<Control> itr = controlToEditor.keySet().iterator();
// while (itr.hasNext()) {
// Control control = (Control) itr.next();
// if (!control.isDisposed()) {
// control.removeListener(SWT.Activate, controlListener);
// control.removeListener(SWT.Deactivate, controlListener);
// }
// }
//controlToEditor.clear();
if (activeEditor != null) {
Control control = activeEditor.getControl();
if (!control.isDisposed()) {
control.removeListener(SWT.Activate, controlListener);
control.removeListener(SWT.Deactivate, controlListener);
}
activeEditor.removePropertyChangeListener(cellListener);
}
activeEditor = null;
}
/**
* Removes a <code>CellEditor</code> from the handler
* so that the Cut, Copy, Paste, Delete, Select All, Find
* Undo, and Redo actions are no longer redirected to it.
*
* @param editor the <code>CellEditor</code>
*/
// public void removeCellEditor(CellEditor editor) {
// if (editor == null) {
// return;
// }
//
// if (activeEditor == editor) {
// activeEditor.removePropertyChangeListener(cellListener);
// activeEditor = null;
// }
//
// Control control = editor.getControl();
// if (control != null) {
// controlToEditor.remove(control);
// if (!control.isDisposed()) {
// control.removeListener(SWT.Activate, controlListener);
// control.removeListener(SWT.Deactivate, controlListener);
// }
// }
// }
/**
* Sets the default <code>IAction</code> handler for the Copy
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Copy action, or <code>null</code> if not interested.
*/
public void setCopyAction(IAction action) {
if (copyAction == action) {
return;
}
if (copyAction != null) {
copyAction.removePropertyChangeListener(copyActionListener);
}
copyAction = action;
if (copyAction != null) {
copyAction.addPropertyChangeListener(copyActionListener);
}
cellCopyAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Cut
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Cut action, or <code>null</code> if not interested.
*/
public void setCutAction(IAction action) {
if (cutAction == action) {
return;
}
if (cutAction != null) {
cutAction.removePropertyChangeListener(cutActionListener);
}
cutAction = action;
if (cutAction != null) {
cutAction.addPropertyChangeListener(cutActionListener);
}
cellCutAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Delete
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Delete action, or <code>null</code> if not interested.
*/
public void setDeleteAction(IAction action) {
if (deleteAction == action) {
return;
}
if (deleteAction != null) {
deleteAction.removePropertyChangeListener(deleteActionListener);
}
deleteAction = action;
if (deleteAction != null) {
deleteAction.addPropertyChangeListener(deleteActionListener);
}
cellDeleteAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Find
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Find action, or <code>null</code> if not interested.
*/
public void setFindAction(IAction action) {
if (findAction == action) {
return;
}
if (findAction != null) {
findAction.removePropertyChangeListener(findActionListener);
}
findAction = action;
if (findAction != null) {
findAction.addPropertyChangeListener(findActionListener);
}
cellFindAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Paste
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Paste action, or <code>null</code> if not interested.
*/
public void setPasteAction(IAction action) {
if (pasteAction == action) {
return;
}
if (pasteAction != null) {
pasteAction.removePropertyChangeListener(pasteActionListener);
}
pasteAction = action;
if (pasteAction != null) {
pasteAction.addPropertyChangeListener(pasteActionListener);
}
cellPasteAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Redo
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Redo action, or <code>null</code> if not interested.
*/
public void setRedoAction(IAction action) {
if (redoAction == action) {
return;
}
if (redoAction != null) {
redoAction.removePropertyChangeListener(redoActionListener);
}
redoAction = action;
if (redoAction != null) {
redoAction.addPropertyChangeListener(redoActionListener);
}
cellRedoAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Select All
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Select All action, or <code>null</code> if not interested.
*/
public void setSelectAllAction(IAction action) {
if (selectAllAction == action) {
return;
}
if (selectAllAction != null) {
selectAllAction
.removePropertyChangeListener(selectAllActionListener);
}
selectAllAction = action;
if (selectAllAction != null) {
selectAllAction.addPropertyChangeListener(selectAllActionListener);
}
cellSelectAllAction.updateEnabledState();
}
/**
* Sets the default <code>IAction</code> handler for the Undo
* action. This <code>IAction</code> is run only if no active
* cell editor control.
*
* @param action the <code>IAction</code> to run for the
* Undo action, or <code>null</code> if not interested.
*/
public void setUndoAction(IAction action) {
if (undoAction == action) {
return;
}
if (undoAction != null) {
undoAction.removePropertyChangeListener(undoActionListener);
}
undoAction = action;
if (undoAction != null) {
undoAction.addPropertyChangeListener(undoActionListener);
}
cellUndoAction.updateEnabledState();
}
/**
* Updates the enable state of the Cut, Copy,
* Paste, Delete, Select All, Find, Undo, and
* Redo action handlers
*/
private void updateActionsEnableState() {
cellCutAction.updateEnabledState();
cellCopyAction.updateEnabledState();
cellPasteAction.updateEnabledState();
cellDeleteAction.updateEnabledState();
cellSelectAllAction.updateEnabledState();
cellFindAction.updateEnabledState();
cellUndoAction.updateEnabledState();
cellRedoAction.updateEnabledState();
}
public void setActiveCellEditor(CellEditor editor) {
// Remove old listener
if (this.activeEditor != null)
this.activeEditor.removePropertyChangeListener(cellListener);
if (editor != null) {
Control control = editor.getControl();
if (control != null && !control.isDisposed()) {
control.addListener(SWT.Activate, controlListener);
control.addListener(SWT.Deactivate, controlListener);
}
editor.addPropertyChangeListener(cellListener);
updateActionsEnableState();
}
this.activeEditor = editor;
}
}