Attachment #122372 for bug #234044

Lines 4-10 Link Here

(-)META-INF/MANIFEST.MF (+3 lines)
4	Bundle-SymbolicName: org.eclipse.mylyn.commons.ui;singleton:=true	4	Bundle-SymbolicName: org.eclipse.mylyn.commons.ui;singleton:=true
5	Bundle-Version: 3.1.0.qualifier	5	Bundle-Version: 3.1.0.qualifier
6	Require-Bundle: org.eclipse.core.runtime,	6	Require-Bundle: org.eclipse.core.runtime,
		7	org.eclipse.core.expressions,
		8	org.eclipse.jface.text,
7	org.eclipse.ui,	9	org.eclipse.ui,
		10	org.eclipse.ui.editors;resolution:=optional,
8	org.eclipse.ui.forms;resolution:=optional	11	org.eclipse.ui.forms;resolution:=optional
9	Bundle-ActivationPolicy: lazy	12	Bundle-ActivationPolicy: lazy
10	Bundle-RequiredExecutionEnvironment: J2SE-1.5	13	Bundle-RequiredExecutionEnvironment: J2SE-1.5




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.provisional.commons.ui;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;

/**
 * @author Mik Kersten
 * @author Rob Elves
 * @author Steffen Pingel
 */
@SuppressWarnings("restriction")
public class WorkbenchActionSupport implements ISelectionChangedListener {

	private class GlobalAction extends Action {

		private final String actionId;

		public GlobalAction(String actionId) {
			this.actionId = actionId;
		}

		@Override
		public void run() {
			if (callback != null) {
				callback.doAction(actionId, callback.getFocusControl());
				updateActions(callback.getSelection());
			}
		}

		public void selectionChanged(ISelection selection) {
			if (callback != null) {
				setEnabled(callback.canPerformAction(actionId, callback.getFocusControl()));
			} else {
				setEnabled(false);
			}
		}
	}

	public static class WorkbenchActionCallback {

		public boolean canPerformAction(String actionId, Control control) {
			return CommonTextSupport.canPerformAction(actionId, control);
		}

		public void doAction(String actionId, Control control) {
			CommonTextSupport.doAction(actionId, control);
		}

		public Control getFocusControl() {
			return Display.getDefault().getFocusControl();
		}

		public ISelection getSelection() {
			IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
			if (window != null && window.getSelectionService() != null) {
				return window.getSelectionService().getSelection();
			}
			return null;
		}

	}

	private WorkbenchActionCallback callback;

	private final GlobalAction copyAction;

	private final GlobalAction cutAction;

	private final GlobalAction findAction;

	private final GlobalAction pasteAction;

	private final GlobalAction redoAction;

	private final GlobalAction selectAllAction;

	private final GlobalAction undoAction;

	public WorkbenchActionSupport() {
		cutAction = new GlobalAction(ActionFactory.CUT.getId());
		cutAction.setText(WorkbenchMessages.Workbench_cut);
		cutAction.setToolTipText(WorkbenchMessages.Workbench_cutToolTip);
		cutAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
		cutAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
		cutAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT_DISABLED));
		cutAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.CUT);

		pasteAction = new GlobalAction(ActionFactory.PASTE.getId());
		pasteAction.setText(WorkbenchMessages.Workbench_paste);
		pasteAction.setToolTipText(WorkbenchMessages.Workbench_pasteToolTip);
		pasteAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
		pasteAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
		pasteAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED));
		pasteAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);

		copyAction = new GlobalAction(ActionFactory.COPY.getId());
		copyAction.setText(WorkbenchMessages.Workbench_copy);
		copyAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
		copyAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
		copyAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));
		copyAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.COPY);

		undoAction = new GlobalAction(ActionFactory.UNDO.getId());
		undoAction.setText(WorkbenchMessages.Workbench_undo);
		undoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
		undoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
		undoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_DISABLED));
		undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);

		redoAction = new GlobalAction(ActionFactory.REDO.getId());
		redoAction.setText(WorkbenchMessages.Workbench_redo);
		redoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
		redoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
		redoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_DISABLED));
		redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);

		selectAllAction = new GlobalAction(ActionFactory.SELECT_ALL.getId());
		selectAllAction.setText(WorkbenchMessages.Workbench_selectAll);
		selectAllAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.SELECT_ALL);
		selectAllAction.setEnabled(true);

		findAction = new GlobalAction(ActionFactory.FIND.getId());
		findAction.setText(WorkbenchMessages.Workbench_findReplace);
		findAction.setImageDescriptor(CommonImages.FIND);
		findAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.FIND_REPLACE);
	}

	public void contributeActions(IMenuManager manager) {
		manager.add(undoAction);
		manager.add(redoAction);
		manager.add(new Separator());
		manager.add(cutAction);
		manager.add(copyAction);
		manager.add(pasteAction);
		manager.add(selectAllAction);
		manager.add(new Separator());
	}

	public void forceEditActionsEnabled() {
		cutAction.setEnabled(true);
		copyAction.setEnabled(true);
		pasteAction.setEnabled(true);
		selectAllAction.setEnabled(true);
		undoAction.setEnabled(false);
		redoAction.setEnabled(false);
	}

	public WorkbenchActionCallback getCallback() {
		return callback;
	}

	public Action getCopyAction() {
		return copyAction;
	}

	public Action getCutAction() {
		return cutAction;
	}

	public Action getFindAction() {
		return findAction;
	}

	public Action getPasteAction() {
		return pasteAction;
	}

	public Action getRedoAction() {
		return redoAction;
	}

	public Action getSelectAllAction() {
		return selectAllAction;
	}

	public Action getUndoAction() {
		return undoAction;
	}

	public void install(IActionBars bars) {
		bars.setGlobalActionHandler(ActionFactory.CUT.getId(), cutAction);
		bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), pasteAction);
		bars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction);
		bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);
		bars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);
		bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), selectAllAction);
		bars.setGlobalActionHandler(ActionFactory.FIND.getId(), findAction);
		bars.updateActionBars();
	}

	public void selectionChanged(SelectionChangedEvent event) {
		ISelection selection = event.getSelection();
		if (selection instanceof TextSelection) {
			// only update global actions
			updateActions(event.getSelection());
		} else if (selection.isEmpty()) {
			// XXX a styled text widget has lost focus, re-enable all edit actions
			forceEditActionsEnabled();
		}
	}

	public void setCallback(WorkbenchActionCallback callback) {
		this.callback = callback;
	}

	public void uninstall(IActionBars bars) {
		bars.setGlobalActionHandler(ActionFactory.CUT.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.COPY.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.REDO.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.FIND.getId(), null);
		bars.updateActionBars();
	}

	public void updateActions(ISelection selection) {
		cutAction.selectionChanged(selection);
		copyAction.selectionChanged(selection);
		pasteAction.selectionChanged(selection);
		undoAction.selectionChanged(selection);
		redoAction.selectionChanged(selection);
		selectAllAction.selectionChanged(selection);
		findAction.selectionChanged(selection);
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.provisional.commons.ui;

import java.util.Iterator;

import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.ITextOperationTarget;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.source.AnnotationModel;
import org.eclipse.jface.text.source.IAnnotationAccess;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.ActiveShellExpression;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.texteditor.AnnotationPreference;
import org.eclipse.ui.texteditor.DefaultMarkerAnnotationAccess;
import org.eclipse.ui.texteditor.MarkerAnnotationPreferences;
import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;

/**
 * @author Steffen Pingel
 */
public class CommonTextSupport {

	private class TextViewerFocusListener implements FocusListener {

		private final boolean spellCheck;

		private final TextViewer viewer;

		public TextViewerFocusListener(TextViewer viewer, boolean spellCheck) {
			this.viewer = viewer;
			this.spellCheck = spellCheck;
		}

		public void focusGained(FocusEvent e) {
			if (selectionChangedListener != null) {
				selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, viewer.getSelection()));
			}
			activateHandlers(viewer, spellCheck);
		}

		public void focusLost(FocusEvent e) {
			deactivateHandlers();
			if (selectionChangedListener != null) {
				// make sure selection no text is selected when control looses focus
				StyledText st = (StyledText) e.widget;
				st.setSelectionRange(st.getCaretOffset(), 0);
				// update action enablement
				selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, StructuredSelection.EMPTY));
			}
		}

	}

	private static String CONTENT_ASSIST_PROPOSALS = "org.eclipse.ui.edit.text.contentAssist.proposals"; //$NON-NLS-1$

	private static final String KEY_TEXT_VIEWER = "textViewer"; //$NON-NLS-1$

	private static final String QUICK_ASSIST = "org.eclipse.jdt.ui.edit.text.java.correction.assist.proposals"; //$NON-NLS-1$

	private static boolean canDoGlobalAction(String actionId, TextViewer textViewer) {
		if (actionId.equals(ActionFactory.CUT.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.CUT);
		} else if (actionId.equals(ActionFactory.COPY.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.COPY);
		} else if (actionId.equals(ActionFactory.PASTE.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.PASTE);
		} else if (actionId.equals(ActionFactory.DELETE.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.DELETE);
		} else if (actionId.equals(ActionFactory.UNDO.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.UNDO);
		} else if (actionId.equals(ActionFactory.REDO.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.REDO);
		} else if (actionId.equals(ActionFactory.SELECT_ALL.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.SELECT_ALL);
		}
		return false;
	}

	public static boolean canPerformAction(String actionId, Control focusControl) {
		TextViewer viewer = getTextViewer(focusControl);
		if (viewer != null) {
			return canDoGlobalAction(actionId, viewer);
		}
		if (actionId.equals(ActionFactory.UNDO.getId()) || actionId.equals(ActionFactory.REDO.getId())) {
			return false;
		}
		return true;
	}

	private static boolean canPerformDirectly(String id, Control control) {
		if (control instanceof Text) {
			Text text = (Text) control;
			if (id.equals(ActionFactory.CUT.getId())) {
				text.cut();
				return true;
			}
			if (id.equals(ActionFactory.COPY.getId())) {
				text.copy();
				return true;
			}
			if (id.equals(ActionFactory.PASTE.getId())) {
				text.paste();
				return true;
			}
			if (id.equals(ActionFactory.SELECT_ALL.getId())) {
				text.selectAll();
				return true;
			}
			if (id.equals(ActionFactory.DELETE.getId())) {
				int count = text.getSelectionCount();
				if (count == 0) {
					int caretPos = text.getCaretPosition();
					text.setSelection(caretPos, caretPos + 1);
				}
				text.insert(""); //$NON-NLS-1$
				return true;
			}
		}
		return false;
	}

	public static void doAction(String actionId, Control focusControl) {
		if (canPerformDirectly(actionId, focusControl)) {
			return;
		}
		TextViewer viewer = getTextViewer(focusControl);
		if (viewer != null) {
			doGlobalAction(actionId, viewer);
		}
	}

	private static boolean doGlobalAction(String actionId, TextViewer textViewer) {
		if (actionId.equals(ActionFactory.CUT.getId())) {
			textViewer.doOperation(ITextOperationTarget.CUT);
			return true;
		} else if (actionId.equals(ActionFactory.COPY.getId())) {
			textViewer.doOperation(ITextOperationTarget.COPY);
			return true;
		} else if (actionId.equals(ActionFactory.PASTE.getId())) {
			textViewer.doOperation(ITextOperationTarget.PASTE);
			return true;
		} else if (actionId.equals(ActionFactory.DELETE.getId())) {
			textViewer.doOperation(ITextOperationTarget.DELETE);
			return true;
		} else if (actionId.equals(ActionFactory.UNDO.getId())) {
			textViewer.doOperation(ITextOperationTarget.UNDO);
			return true;
		} else if (actionId.equals(ActionFactory.REDO.getId())) {
			textViewer.doOperation(ITextOperationTarget.REDO);
			return true;
		} else if (actionId.equals(ActionFactory.SELECT_ALL.getId())) {
			textViewer.doOperation(ITextOperationTarget.SELECT_ALL);
			return true;
		}
		return false;
	}

	public static TextViewer getTextViewer(Widget widget) {
		if (widget instanceof StyledText) {
			Object data = widget.getData(KEY_TEXT_VIEWER);
			if (data instanceof TextViewer) {
				return (TextViewer) data;
			}
		}
		return null;
	}

	public static void setTextViewer(Widget widget, TextViewer textViewer) {
		widget.setData(KEY_TEXT_VIEWER, textViewer);
	}

	public IHandlerActivation contentAssistHandlerActivation;

	private final IHandlerService handlerService;

	private IHandlerActivation quickAssistHandlerActivation;

	private ISelectionChangedListener selectionChangedListener;

	public CommonTextSupport(IHandlerService handlerService) {
		this.handlerService = handlerService;
	}

	private IHandlerActivation activateHandler(TextViewer viewer, int operation, String actionDefinitionId) {
		IHandler handler = createActionHandler(viewer, operation, actionDefinitionId);
		return handlerService.activateHandler(actionDefinitionId, handler, //
				new ActiveShellExpression(viewer.getTextWidget().getShell()));
	}

	private void activateHandlers(TextViewer viewer, boolean spellCheck) {
		deactivateHandlers();
		if (spellCheck) {
			quickAssistHandlerActivation = activateHandler(viewer, ISourceViewer.QUICK_ASSIST, QUICK_ASSIST);
		}
		contentAssistHandlerActivation = activateHandler(viewer, ISourceViewer.CONTENTASSIST_PROPOSALS,
				CONTENT_ASSIST_PROPOSALS);
	}

	public void configure(final TextViewer viewer, Document document, boolean spellCheck) {
		if (spellCheck && viewer instanceof ISourceViewer) {
			configureAsEditor((ISourceViewer) viewer, document);
		} else {
			viewer.setDocument(document);
		}
		install(viewer, spellCheck);
	}

	/** Configures annotation model for spell checking. */
	private void configureAsEditor(ISourceViewer viewer, Document document) {
		IAnnotationAccess annotationAccess = new DefaultMarkerAnnotationAccess();
		final SourceViewerDecorationSupport support = new SourceViewerDecorationSupport(viewer, null, annotationAccess,
				EditorsUI.getSharedTextColors());
		Iterator<?> e = new MarkerAnnotationPreferences().getAnnotationPreferences().iterator();
		while (e.hasNext()) {
			support.setAnnotationPreference((AnnotationPreference) e.next());
		}
		support.install(EditorsUI.getPreferenceStore());
		viewer.getTextWidget().addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				support.uninstall();
			}
		});
		AnnotationModel annotationModel = new AnnotationModel();
		viewer.setDocument(document, annotationModel);
	}

	private IHandler createActionHandler(final ITextOperationTarget viewer, final int operation,
			String actionDefinitionId) {
		Action action = new Action() {
			@Override
			public void run() {
				if (viewer.canDoOperation(operation)) {
					viewer.doOperation(operation);
				}
			}
		};
		action.setActionDefinitionId(actionDefinitionId);
		return new ActionHandler(action);
	}

	private void deactivateHandlers() {
		if (quickAssistHandlerActivation != null) {
			handlerService.deactivateHandler(quickAssistHandlerActivation);
			quickAssistHandlerActivation = null;
		}
		if (contentAssistHandlerActivation != null) {
			handlerService.deactivateHandler(contentAssistHandlerActivation);
			contentAssistHandlerActivation = null;
		}
	}

	public void dispose() {
		deactivateHandlers();
	}

	public ISelectionChangedListener getSelectionChangedListener() {
		return selectionChangedListener;
	}

	public void install(final TextViewer viewer, boolean spellCheck) {
		viewer.getControl().addFocusListener(new TextViewerFocusListener(viewer, spellCheck));
		if (selectionChangedListener != null) {
			viewer.addSelectionChangedListener(selectionChangedListener);
			viewer.addTextListener(new ITextListener() {
				public void textChanged(TextEvent event) {
					if (selectionChangedListener != null) {
						selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer,
								viewer.getSelection()));
					}
				}
			});
		}
		setTextViewer(viewer.getControl(), viewer);
	}

	public void setSelectionChangedListener(ISelectionChangedListener selectionChangedListener) {
		this.selectionChangedListener = selectionChangedListener;
	}

}




import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
import org.eclipse.mylyn.internal.provisional.commons.ui.DatePicker;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.DayDateRange;

import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.IFormColors;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormPage;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

import org.eclipse.ui.forms.widgets.ImageHyperlink;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.handlers.IHandlerService;

/**
 * @author Mik Kersten
 * @author Rob Elves
 */
public class TaskPlanningEditor extends FormPage {

	private static final String RESET = Messages.TaskPlanningEditor_Reset;



	private ITaskActivityListener timingListener;

	private boolean isDirty;

	private CommonTextSupport textSupport;

	public TaskPlanningEditor(TaskEditor editor) {
		super(editor, ITasksUiConstants.ID_PAGE_PLANNING, Messages.TaskPlanningEditor_Planning);
		this.parentEditor = editor;
		TasksUiInternal.getTaskList().addChangeListener(TASK_LIST_LISTENER);
	}

	@Override
	public void init(IEditorSite site, IEditorInput input) {
		super.init(site, input);
		this.textSupport = new CommonTextSupport((IHandlerService) getSite().getService(IHandlerService.class));
		this.textSupport.setSelectionChangedListener((TaskEditorActionContributor) getEditorSite().getActionBarContributor());
	}

	/**
	 * Override for customizing the tool bar.
	 */

		toolkit.paintBordersFor(statusComposite);
	}

	private TextViewer addTextEditor(TaskRepository repository, Composite parent, String text, boolean spellCheck,
			int style) {
		SourceViewer viewer = new SourceViewer(parent, null, style);
		viewer.configure(new RepositoryTextViewerConfiguration(repository, spellCheck));
		textSupport.configure(viewer, new Document(text), spellCheck);
		return viewer;
	}

	private void markDirty(boolean dirty) {
		isDirty = dirty;
		getManagedForm().dirtyStateChanged();
	}

	/**
	 * Attempts to set the task pageTitle to the title from the specified url
	 */




import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchActionSupport;
import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchActionSupport.WorkbenchActionCallback;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;

import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.part.MultiPageEditorActionBarContributor;
import org.eclipse.ui.progress.IProgressService;
import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;

/**
 * @author Mik Kersten

public class TaskEditorActionContributor extends MultiPageEditorActionBarContributor implements
		ISelectionChangedListener {

	private class EditorPageCallback extends WorkbenchActionCallback {

		@Override
		public boolean canPerformAction(String actionId, Control control) {
			IFormPage activePage = getActivePage();
			if (activePage instanceof AbstractTaskEditorPage) {
				AbstractTaskEditorPage page = (AbstractTaskEditorPage) activePage;
				return page.canPerformAction(actionId);
			} else {
				WorkbenchActionCallback textSupport = (WorkbenchActionCallback) activePage.getAdapter(WorkbenchActionCallback.class);
				if (textSupport != null) {
					return textSupport.canPerformAction(actionId, control);
				} else {
					return super.canPerformAction(actionId, control);
				}
			}
		}

		@Override
		public void doAction(String actionId, Control control) {
			IFormPage activePage = getActivePage();
			if (activePage instanceof AbstractTaskEditorPage) {
				AbstractTaskEditorPage page = (AbstractTaskEditorPage) activePage;
				page.doAction(actionId);
			} else {
				WorkbenchActionCallback textSupport = (WorkbenchActionCallback) activePage.getAdapter(WorkbenchActionCallback.class);
				if (textSupport != null) {
					textSupport.doAction(actionId, control);
				} else {
					super.doAction(actionId, control);
				}
			}
		}

		@Override
		public Control getFocusControl() {
			IFormPage page = getActivePage();
			return EditorUtil.getFocusControl(page);
		}

		@Override
		public ISelection getSelection() {
			return TaskEditorActionContributor.this.getSelection();
		}

	}

	private TaskEditor editor;

	private final OpenWithBrowserAction openWithBrowserAction = new OpenWithBrowserAction();

	private final CopyTaskDetailsAction copyTaskDetailsAction = new CopyTaskDetailsAction();

	private final SynchronizeEditorAction synchronizeEditorAction = new SynchronizeEditorAction();

	private final ShowInTaskListAction showInTaskListAction = new ShowInTaskListAction();

	private final NewTaskFromSelectionAction newTaskFromSelectionAction = new NewTaskFromSelectionAction();

	private final WorkbenchActionSupport actionSupport;

	public TaskEditorActionContributor() {
		actionSupport = new WorkbenchActionSupport();
		actionSupport.setCallback(new EditorPageCallback());
		cutAction.setToolTipText(WorkbenchMessages.Workbench_cutToolTip);
		cutAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
		cutAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
		cutAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT_DISABLED));
		cutAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.CUT);

		pasteAction = new GlobalAction(ActionFactory.PASTE.getId());
		pasteAction.setText(WorkbenchMessages.Workbench_paste);
		pasteAction.setToolTipText(WorkbenchMessages.Workbench_pasteToolTip);
		pasteAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
		pasteAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
		pasteAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED));
		pasteAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);

		copyAction = new GlobalAction(ActionFactory.COPY.getId());
		copyAction.setText(WorkbenchMessages.Workbench_copy);
		copyAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
		copyAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
		copyAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));
		copyAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.COPY);

		undoAction = new GlobalAction(ActionFactory.UNDO.getId());
		undoAction.setText(WorkbenchMessages.Workbench_undo);
		undoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
		undoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
		undoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_DISABLED));
		undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);

		redoAction = new GlobalAction(ActionFactory.REDO.getId());
		redoAction.setText(WorkbenchMessages.Workbench_redo);
		redoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
		redoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
		redoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_DISABLED));
		redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);

		selectAllAction = new GlobalAction(ActionFactory.SELECT_ALL.getId());
		selectAllAction.setText(WorkbenchMessages.Workbench_selectAll);
		selectAllAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.SELECT_ALL);
		selectAllAction.setEnabled(true);

		findAction = new GlobalAction(ActionFactory.FIND.getId());
		findAction.setText(Messages.TaskEditorActionContributor_Find);
		findAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.FIND_REPLACE);
		findAction.setImageDescriptor(CommonImages.FIND);
	}

	public void addClipboardActions(IMenuManager manager) {
		manager.add(actionSupport.getUndoAction());
		manager.add(actionSupport.getRedoAction());
		manager.add(new Separator());
		manager.add(actionSupport.getCutAction());
		manager.add(actionSupport.getCopyAction());
		manager.add(copyTaskDetailsAction);
		manager.add(actionSupport.getPasteAction());
		manager.add(actionSupport.getSelectAllAction());
		manager.add(newTaskFromSelectionAction);
		manager.add(new Separator());
	}

		manager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
	}

	@Override
	public void contributeToCoolBar(ICoolBarManager cbm) {
		if (input instanceof TaskEditorInput) {
			TaskEditorInput repositoryTaskEditorInput = (TaskEditorInput) input;
			final IProgressService svc = PlatformUI.getWorkbench().getProgressService();
			final AddExistingTaskJob job = new AddExistingTaskJob(repositoryTaskEditorInput.getTaskRepository(),
					repositoryTaskEditorInput.getTask().getTaskId(), category);
			job.schedule();
			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
				public void run() {
					svc.showInDialog(getEditor().getSite().getShell(), job);
				}
			});
		}
	}

	public void updateSelectableActions(ISelection selection) {
		if (editor != null) {
			cutAction.selectionChanged(selection);
			copyAction.selectionChanged(selection);
			pasteAction.selectionChanged(selection);
			undoAction.selectionChanged(selection);
			redoAction.selectionChanged(selection);
			selectAllAction.selectionChanged(selection);
			newTaskFromSelectionAction.selectionChanged(selection);
			findAction.selectionChanged(selection);
		}
	}

	@Override

	public void contributeToToolBar(IToolBarManager tbm) {
	}

	public void forceActionsEnabled() {
		actionSupport.forceEditActionsEnabled();
	}

	private IFormPage getActivePage() {
		return (editor != null) ? editor.getActivePageInstance() : null;
		super.init(bars, page);
		registerGlobalHandlers(bars);
		findAction.selectionChanged(StructuredSelection.EMPTY);
	}

	public TaskEditor getEditor() {
		return editor;
	}

	public ISelection getSelection() {
		if (editor != null && editor.getSite().getSelectionProvider() != null) {
			return editor.getSite().getSelectionProvider().getSelection();
			this.editor = (TaskEditor) activeEditor;
			updateSelectableActions(getSelection());
		} else {
			return StructuredSelection.EMPTY;
		}
	}

	@Override
	public void init(IActionBars bars, IWorkbenchPage page) {
		super.init(bars, page);
		actionSupport.install(bars);

	public void selectionChanged(SelectionChangedEvent event) {
		updateSelectableActions(event.getSelection());
	}

	private void moveToCategory(AbstractTaskCategory category) {
		IEditorInput input = getEditor().getEditorInput();
		if (input instanceof TaskEditorInput) {
			TaskEditorInput repositoryTaskEditorInput = (TaskEditorInput) input;
			final IProgressService svc = PlatformUI.getWorkbench().getProgressService();
			final AddExistingTaskJob job = new AddExistingTaskJob(repositoryTaskEditorInput.getTaskRepository(),
					repositoryTaskEditorInput.getTask().getTaskId(), category);
			job.schedule();
			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
				public void run() {
					svc.showInDialog(getEditor().getSite().getShell(), job);
				}
			});
				editor.doAction(actionId);
			} else if (page instanceof AbstractTaskEditorPage) {
				AbstractTaskEditorPage editor = (AbstractTaskEditorPage) page;
				editor.doAction(actionId);
			} else {
				EditorUtil.doAction(actionId, EditorUtil.getFocusControl(getActivePage()));
			}
			updateSelectableActions(getSelection());
		}

		public void selectionChanged(ISelection selection) {
			IFormPage page = getActivePage();
			if (page instanceof TaskFormPage) {
				TaskFormPage editor = (TaskFormPage) page;
				setEnabled(editor.canPerformAction(actionId));
			} else if (page instanceof AbstractTaskEditorPage) {
				AbstractTaskEditorPage editor = (AbstractTaskEditorPage) page;
				setEnabled(editor.canPerformAction(actionId));
			} else {
				setEnabled(EditorUtil.canPerformAction(actionId, EditorUtil.getFocusControl(getActivePage())));
			}
		}
	}

	public void selectionChanged(SelectionChangedEvent event) {
		actionSupport.selectionChanged(event);
		newTaskFromSelectionAction.selectionChanged(event.getSelection());
		bars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction);
		bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);
		bars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);
		bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), selectAllAction);
		bars.setGlobalActionHandler(ActionFactory.FIND.getId(), findAction);
		bars.updateActionBars();
	}

	@SuppressWarnings("unused")
	private void unregisterGlobalHandlers(IActionBars bars) {
		bars.setGlobalActionHandler(ActionFactory.CUT.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.COPY.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.REDO.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null);
		bars.setGlobalActionHandler(ActionFactory.FIND.getId(), null);
		bars.updateActionBars();
	}

	@Override
	public void setActiveEditor(IEditorPart activeEditor) {
		if (activeEditor instanceof TaskEditor) {
			this.editor = (TaskEditor) activeEditor;
			updateSelectableActions(getSelection());
		} else {
			this.editor = null;
		}
	}

	@Override
	public void setActivePage(IEditorPart activePage) {
		updateSelectableActions(getSelection());
	}

	public void updateSelectableActions(ISelection selection) {
		if (editor != null) {
			actionSupport.updateActions(selection);
			newTaskFromSelectionAction.selectionChanged(selection);
			return StructuredSelection.EMPTY;
		}
	}





/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * 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:
 *     Tasktop Technologies - initial API and implementation
 *     Eugene Kuleshov - spelling correction
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.editors;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.commands.IHandler;
import org.eclipse.core.resources.IMarker;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.text.DefaultInformationControl;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.ITextOperationTarget;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.AnnotationModel;
import org.eclipse.jface.text.source.IAnnotationAccess;
import org.eclipse.jface.text.source.IAnnotationAccessExtension;
import org.eclipse.jface.text.source.IAnnotationHover;
import org.eclipse.jface.text.source.ISharedTextColors;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.ImageUtilities;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonColors;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.ActiveShellExpression;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.editor.FormPage;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.texteditor.AnnotationPreference;
import org.eclipse.ui.texteditor.DefaultMarkerAnnotationAccess;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
import org.eclipse.ui.texteditor.MarkerAnnotationPreferences;
import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;
import org.eclipse.ui.themes.IThemeManager;

/**
 * Used by the task editor. Not recommended to extend.
 * 
 * @author Rob Elves
 * 
 *         ref: PDEFormPage.class ref: ref: http://dev.eclipse.org/newslists/news.eclipse.platform.swt/msg19676.html
 * @deprecated use {@link AbstractTaskEditorPage} instead
 */
@Deprecated
public class TaskFormPage extends FormPage {

	protected boolean isDirty;

	private TaskEditor taskEditor = null;

	private TaskEditorActionContributor actionContributor;

	protected List<TextViewer> textViewers = new ArrayList<TextViewer>();

	private IHandlerActivation handlerActivation;

	private IHandlerActivation handlerCompletion;

	private void addTextViewer(TextViewer viewer) {
		textViewers.add(viewer);
	}

	public TaskFormPage(FormEditor editor, String id, String title) {
		super(editor, id, title);
		taskEditor = (TaskEditor) editor;
	}

	public boolean canPerformAction(String actionId) {
		Control focusControl = getFocusControl();
		if (focusControl instanceof StyledText) {
			StyledText text = (StyledText) focusControl;
			for (TextViewer viewer : textViewers) {
				if (viewer.getTextWidget() == text) {
					return canDoGlobalAction(actionId, viewer);
				}
			}
		} else {
			if (actionId.equals(ActionFactory.UNDO.getId()) || actionId.equals(ActionFactory.REDO.getId())) {
				return false;
			} else {
				return true;
			}
		}
		// else if (focusControl instanceof Text) {
		//
		// Text textControl = (Text) focusControl;
		// if (actionId.equals(ActionFactory.CUT.getId())) {
		// return textControl.getSelectionText().length() > 0;
		// }
		// if (actionId.equals(ActionFactory.COPY.getId())) {
		// return textControl.getSelectionText().length() > 0;
		// }
		// if (actionId.equals(ActionFactory.PASTE.getId())) {
		// return true;
		// }
		// if (actionId.equals(ActionFactory.SELECT_ALL.getId())) {
		// return textControl.getText().length() > 0;
		// }
		// if (actionId.equals(ActionFactory.DELETE.getId())) {
		// return textControl.getSelectionText().length() > 0;
		// }
		// }
		return false;
	}

	public void doAction(String actionId) {
		Control focusControl = getFocusControl();
		if (focusControl == null) {
			return;
		}
		if (canPerformDirectly(actionId, focusControl)) {
			return;
		}
		if (focusControl instanceof StyledText) {
			StyledText text = (StyledText) focusControl;
			for (TextViewer viewer : textViewers) {
				if (viewer.getTextWidget() == text) {
					doGlobalAction(actionId, viewer);
					return;
				}
			}
		}
	}

	protected boolean canPerformDirectly(String id, Control control) {
		if (control instanceof Text) {
			Text text = (Text) control;
			if (id.equals(ActionFactory.CUT.getId())) {
				text.cut();
				return true;
			}
			if (id.equals(ActionFactory.COPY.getId())) {
				text.copy();
				return true;
			}
			if (id.equals(ActionFactory.PASTE.getId())) {
				text.paste();
				return true;
			}
			if (id.equals(ActionFactory.SELECT_ALL.getId())) {
				text.selectAll();
				return true;
			}
			if (id.equals(ActionFactory.DELETE.getId())) {
				int count = text.getSelectionCount();
				if (count == 0) {
					int caretPos = text.getCaretPosition();
					text.setSelection(caretPos, caretPos + 1);
				}
				text.insert(""); //$NON-NLS-1$
				return true;
			}
		}
		return false;
	}

	protected Control getFocusControl() {
		IManagedForm form = getManagedForm();
		if (form == null) {
			return null;
		}
		Control control = form.getForm();
		if (control == null || control.isDisposed()) {
			return null;
		}
		Display display = control.getDisplay();
		Control focusControl = display.getFocusControl();
		if (focusControl == null || focusControl.isDisposed()) {
			return null;
		}
		return focusControl;
	}

	private boolean doGlobalAction(String actionId, TextViewer textViewer) {
		if (actionId.equals(ActionFactory.CUT.getId())) {
			textViewer.doOperation(ITextOperationTarget.CUT);
			return true;
		} else if (actionId.equals(ActionFactory.COPY.getId())) {
			textViewer.doOperation(ITextOperationTarget.COPY);
			return true;
		} else if (actionId.equals(ActionFactory.PASTE.getId())) {
			textViewer.doOperation(ITextOperationTarget.PASTE);
			return true;
		} else if (actionId.equals(ActionFactory.DELETE.getId())) {
			textViewer.doOperation(ITextOperationTarget.DELETE);
			return true;
		} else if (actionId.equals(ActionFactory.UNDO.getId())) {
			textViewer.doOperation(ITextOperationTarget.UNDO);
			return true;
		} else if (actionId.equals(ActionFactory.REDO.getId())) {
			textViewer.doOperation(ITextOperationTarget.REDO);
			return true;
		} else if (actionId.equals(ActionFactory.SELECT_ALL.getId())) {
			textViewer.doOperation(ITextOperationTarget.SELECT_ALL);
			return true;
		}
		return false;
	}

	private boolean canDoGlobalAction(String actionId, TextViewer textViewer) {
		if (actionId.equals(ActionFactory.CUT.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.CUT);
		} else if (actionId.equals(ActionFactory.COPY.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.COPY);
		} else if (actionId.equals(ActionFactory.PASTE.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.PASTE);
		} else if (actionId.equals(ActionFactory.DELETE.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.DELETE);
		} else if (actionId.equals(ActionFactory.UNDO.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.UNDO);
		} else if (actionId.equals(ActionFactory.REDO.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.REDO);
		} else if (actionId.equals(ActionFactory.SELECT_ALL.getId())) {
			return textViewer.canDoOperation(ITextOperationTarget.SELECT_ALL);
		}
		return false;
	}

	/**
	 * Text viewer generally used for displaying non-editable text. No annotation model or spell checking support.
	 * Supports cut/copy/paste/etc..
	 */
	protected TextViewer addTextViewer(TaskRepository repository, Composite composite, String text, int style) {

		if (actionContributor == null) {
			actionContributor = (TaskEditorActionContributor) getEditorSite().getActionBarContributor();
		}

		final RepositoryTextViewer commentViewer = new RepositoryTextViewer(repository, composite, style);

		// NOTE: Configuration must be applied before the document is set in
		// order for
		// Hyperlink colouring to work. (Presenter needs document object up
		// front)
		RepositoryTextViewerConfiguration repositoryViewerConfig = new RepositoryTextViewerConfiguration(repository,
				false);
		commentViewer.configure(repositoryViewerConfig);

		IThemeManager themeManager = getSite().getWorkbenchWindow().getWorkbench().getThemeManager();

		commentViewer.getTextWidget().setFont(
				themeManager.getCurrentTheme().getFontRegistry().get(CommonThemes.FONT_EDITOR_COMMENT));

		commentViewer.addSelectionChangedListener(actionContributor);

		commentViewer.getTextWidget().addFocusListener(new FocusListener() {

			public void focusGained(FocusEvent e) {

				actionContributor.updateSelectableActions(commentViewer.getSelection());

			}

			public void focusLost(FocusEvent e) {
				StyledText st = (StyledText) e.widget;
				st.setSelectionRange(st.getCaretOffset(), 0);
				actionContributor.forceActionsEnabled();
			}
		});

		commentViewer.addTextListener(new ITextListener() {
			public void textChanged(TextEvent event) {
				actionContributor.updateSelectableActions(commentViewer.getSelection());
			}
		});

		commentViewer.setEditable(false);
		MenuManager manager = commentViewer.getMenuManager();
		taskEditor.configureContextMenuManager(manager);
		commentViewer.setMenu(manager.createContextMenu(commentViewer.getTextWidget()));
		Document document = new Document(text);
		commentViewer.setDocument(document);

		addTextViewer(commentViewer);
		return commentViewer;
	}

	/**
	 * For viewing and editing text. Spell checking w/ annotations supported One or two max per editor, any more and the
	 * spell checker will bring the editor to a grinding halt.
	 */
	protected TextViewer addTextEditor(TaskRepository repository, Composite composite, String text, boolean spellCheck,
			int style) {

		if (actionContributor == null) {
			actionContributor = (TaskEditorActionContributor) getEditorSite().getActionBarContributor();
		}

		AnnotationModel annotationModel = new AnnotationModel();
		final RepositoryTextViewer commentViewer = new RepositoryTextViewer(null, null, repository, composite, style);
		commentViewer.showAnnotations(false);
		commentViewer.showAnnotationsOverview(false);

		IAnnotationAccess annotationAccess = new DefaultMarkerAnnotationAccess();

		final SourceViewerDecorationSupport support = new SourceViewerDecorationSupport(commentViewer, null,
				annotationAccess, EditorsUI.getSharedTextColors());

		@SuppressWarnings("unchecked")
		Iterator e = new MarkerAnnotationPreferences().getAnnotationPreferences().iterator();
		while (e.hasNext()) {
			support.setAnnotationPreference((AnnotationPreference) e.next());
		}

		support.install(EditorsUI.getPreferenceStore());

		commentViewer.getTextWidget().setIndent(2);
		commentViewer.getTextWidget().addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				support.uninstall();
			}
		});

		final IHandlerService handlerService = (IHandlerService) PlatformUI.getWorkbench().getService(
				IHandlerService.class);

		IThemeManager themeManager = getSite().getWorkbenchWindow().getWorkbench().getThemeManager();

		commentViewer.getTextWidget().setFont(
				themeManager.getCurrentTheme().getFontRegistry().get(CommonThemes.FONT_EDITOR_COMMENT));

		commentViewer.addSelectionChangedListener(actionContributor);

		commentViewer.getTextWidget().addFocusListener(new FocusListener() {

			public void focusGained(FocusEvent e) {
				actionContributor.updateSelectableActions(commentViewer.getSelection());
				activate();
			}

			public void focusLost(FocusEvent e) {
				StyledText st = (StyledText) e.widget;
				st.setSelectionRange(st.getCaretOffset(), 0);
				actionContributor.forceActionsEnabled();

				deactivate();
			}

			private void activate() {
				deactivate();
				if (handlerActivation == null) {
					handlerActivation = handlerService.activateHandler( //
							ITextEditorActionDefinitionIds.QUICK_ASSIST, //
							createQuickFixActionHandler(commentViewer), // 
							new ActiveShellExpression(commentViewer.getTextWidget().getShell()));
				}
				if (handlerCompletion == null) {
					handlerCompletion = handlerService.activateHandler( //
							ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS, //
							createContentAssistActionHandler(commentViewer), //
							new ActiveShellExpression(commentViewer.getTextWidget().getShell()));
				}
			}

			private void deactivate() {
				if (handlerCompletion != null) {
					handlerService.deactivateHandler(handlerCompletion);
					handlerCompletion = null;
				}
				if (handlerActivation != null) {
					handlerService.deactivateHandler(handlerActivation);
					handlerActivation = null;
				}
			}
		});

		commentViewer.addTextListener(new ITextListener() {
			public void textChanged(TextEvent event) {
				actionContributor.updateSelectableActions(commentViewer.getSelection());
			}
		});

		commentViewer.setEditable(false);
		MenuManager manager = commentViewer.getMenuManager();
		taskEditor.configureContextMenuManager(manager);
		commentViewer.setMenu(manager.createContextMenu(commentViewer.getTextWidget()));
		Document document = new Document(text);

		// NOTE: Configuration must be applied before the document is set in order for
		// Hyperlink coloring to work. (Presenter needs document object up front)
		TextSourceViewerConfiguration viewerConfig = new RepositoryTextViewerConfiguration(repository, spellCheck);
		commentViewer.configure(viewerConfig);

		commentViewer.setDocument(document, annotationModel);

		// !Do Not Delete! hover manager that shows text when we hover
		// AnnotationBarHoverManager fAnnotationHoverManager = new AnnotationBarHoverManager(fCompositeRuler,
		//     commentViewer, new AnnotationHover(fAnnotationModel), new AnnotationConfiguration());
		// fAnnotationHoverManager.install(annotationRuler.getControl());

		// !Do Not Delete! Sample debugging code
		// document.set("Here's some texst so that we have somewhere to show an error");
		//
		// // // add an annotation
		// ErrorAnnotation errorAnnotation = new ErrorAnnotation(1, "");
		// // lets underline the word "texst"
		// fAnnotationModel.addAnnotation(errorAnnotation, new Position(12, 5));

		// CoreSpellingProblem iProblem = new CoreSpellingProblem(12, 5, 1, 
		//    "problem message", "theword", false, false, document, "task editor");
		// editorInput.getName()
		//
		// fAnnotationModel.addAnnotation(new ProblemAnnotation(iProblem, null), new Position(12, 5));

		addTextViewer(commentViewer);
		return commentViewer;
	}

	private IHandler createQuickFixActionHandler(final SourceViewer viewer) {
		Action quickFixAction = new Action() {
			@Override
			public void run() {
				if (viewer.canDoOperation(ISourceViewer.QUICK_ASSIST)) {
					viewer.doOperation(ISourceViewer.QUICK_ASSIST);
				}
			}
		};
		quickFixAction.setActionDefinitionId(ITextEditorActionDefinitionIds.QUICK_ASSIST);
		return new ActionHandler(quickFixAction);
	}

	private IHandler createContentAssistActionHandler(final SourceViewer viewer) {
		Action quickFixAction = new Action() {
			@Override
			public void run() {
				if (viewer.canDoOperation(ISourceViewer.CONTENTASSIST_PROPOSALS)) {
					viewer.doOperation(ISourceViewer.CONTENTASSIST_PROPOSALS);
				}
			}
		};
		quickFixAction.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
		return new ActionHandler(quickFixAction);
	}

	@Override
	public boolean isDirty() {
		return isDirty;
	}

	public void markDirty(boolean dirty) {
		isDirty = dirty;
		getManagedForm().dirtyStateChanged();
		return;
	}

	static class AnnotationMarkerAccess implements IAnnotationAccess, IAnnotationAccessExtension {
		public Object getType(Annotation annotation) {
			return annotation.getType();
		}

		public boolean isMultiLine(Annotation annotation) {
			return true;
		}

		public boolean isTemporary(Annotation annotation) {
			return !annotation.isPersistent();
		}

		public String getTypeLabel(Annotation annotation) {
			if (annotation instanceof ErrorAnnotation) {
				return Messages.TaskFormPage_Errors;
			}

			return null;
		}

		public int getLayer(Annotation annotation) {
			if (annotation instanceof ErrorAnnotation) {
				return ((ErrorAnnotation) annotation).getLayer();
			}

			return 0;
		}

		public void paint(Annotation annotation, GC gc, Canvas canvas, Rectangle bounds) {
			ImageUtilities.drawImage(((ErrorAnnotation) annotation).getImage(), gc, canvas, bounds, SWT.CENTER, SWT.TOP);
		}

		public boolean isPaintable(Annotation annotation) {
			if (annotation instanceof ErrorAnnotation) {
				return ((ErrorAnnotation) annotation).getImage() != null;
			}

			return false;
		}

		public boolean isSubtype(Object annotationType, Object potentialSupertype) {
			if (annotationType.equals(potentialSupertype)) {
				return true;
			}

			return false;

		}

		public Object[] getSupertypes(Object annotationType) {
			return new Object[0];
		}
	}

	static class AnnotationHover implements IAnnotationHover, ITextHover {

		AnnotationModel fAnnotationModel = null;

		public AnnotationHover(AnnotationModel model) {
			this.fAnnotationModel = model;
		}

		@SuppressWarnings("unchecked")
		public String getHoverInfo(ISourceViewer sourceViewer, int lineNumber) {
			Iterator ite = fAnnotationModel.getAnnotationIterator();

			ArrayList<String> all = new ArrayList<String>();

			while (ite.hasNext()) {
				Annotation a = (Annotation) ite.next();
				if (a instanceof ErrorAnnotation) {
					all.add(((ErrorAnnotation) a).getText());
				}
			}

			StringBuffer total = new StringBuffer();
			for (int x = 0; x < all.size(); x++) {
				String str = all.get(x);
				total.append(" " + str + (x == (all.size() - 1) ? "" : "\n")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			}

			return total.toString();
		}

		public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
			return null;
		}

		public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
			return null;
		}
	}

	public static class ErrorAnnotation extends Annotation {

		public static String ERROR_TYPE = "spelling.error"; //$NON-NLS-1$

		// ProblemAnnotation.SPELLING_ANNOTATION_TYPE;

		private final IMarker marker;

		private String text;

		private int line;

		private Position position;

		public ErrorAnnotation(IMarker marker) {
			this.marker = marker;
		}

		public ErrorAnnotation(int line, String text) {
			super(ERROR_TYPE, true, null);
			this.marker = null;
			this.line = line;
			this.text = text;
		}

		public IMarker getMarker() {
			return marker;
		}

		public int getLine() {
			return line;
		}

		@Override
		public String getText() {
			return text;
		}

		public Image getImage() {
			return null;// ERROR_IMAGE;
		}

		public int getLayer() {
			return 3;
		}

		@Override
		public String getType() {
			return ERROR_TYPE;
		}

		public Position getPosition() {
			return position;
		}

		public void setPosition(Position position) {
			this.position = position;
		}
	}

	// NOTE: See commented code below for example implementation
	static class SharedTextColors implements ISharedTextColors {

		/** Creates an returns a shared color manager. */
		public SharedTextColors() {
			super();
		}

		public Color getColor(RGB rgb) {
			return CommonColors.TEXT_SPELLING_ERROR;
		}

		public void dispose() {
			return;
		}
	}

	// DND relves
	//// From org.eclipse.ui.internal.editors.text.SharedTextColors
	// static class SharedTextColors implements ISharedTextColors {
	// /** The display table. */
	// @SuppressWarnings("unchecked")
	// private Map fDisplayTable;
	//
	// /** Creates an returns a shared color manager. */
	// public SharedTextColors() {
	// super();
	// }
	//
	// /*
	// * @see ISharedTextColors#getColor(RGB)
	// */
	// @SuppressWarnings("unchecked")
	// public Color getColor(RGB rgb) {
	// if (rgb == null)
	// return null;
	//
	// if (fDisplayTable == null)
	// fDisplayTable = new HashMap(2);
	//
	// Display display = Display.getCurrent();
	//
	// Map colorTable = (Map) fDisplayTable.get(display);
	// if (colorTable == null) {
	// colorTable = new HashMap(10);
	// fDisplayTable.put(display, colorTable);
	// }
	//
	// Color color = (Color) colorTable.get(rgb);
	// if (color == null) {
	// color = new Clr(display, rgb);
	// colorTable.put(rgb, color);
	// }
	//
	// return color;
	// }
	//
	// /*
	// * @see ISharedTextColors#dispose()
	// */
	// @SuppressWarnings("unchecked")
	// public void dispose() {
	// if (fDisplayTable != null) {
	// Iterator j = fDisplayTable.values().iterator();
	// while (j.hasNext()) {
	// Iterator i = ((Map) j.next()).values().iterator();
	// while (i.hasNext())
	// ((Color) i.next()).dispose();
	// }
	// }
	// }
	// }

	static class AnnotationConfiguration implements IInformationControlCreator {
		public IInformationControl createInformationControl(Shell shell) {
			return new DefaultInformationControl(shell);
		}
	}

	/**
	 * @since 2.2
	 */
	// TODO 3.1 remove method
	public String getSelectionText() {
		Control focusControl = getFocusControl();
		if (focusControl == null) {
			return null;
		}
		if (focusControl instanceof StyledText) {
			StyledText text = (StyledText) focusControl;
			for (TextViewer viewer : textViewers) {
				if (viewer.getTextWidget() == text) {
					return text.getSelectionText();
				}
			}
		}
		return null;
	}

}

Lines 52-57 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage.java (-3 / +13 lines)
52	import org.eclipse.mylyn.context.core.ContextCore;	52	import org.eclipse.mylyn.context.core.ContextCore;
53	import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;	53	import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
54	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;	54	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
		55	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
55	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;	56	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
56	import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;	57	import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
57	import org.eclipse.mylyn.internal.tasks.core.DateRange;	58	import org.eclipse.mylyn.internal.tasks.core.DateRange;
Lines 449-454 Link Here
449		450
450	private TaskAttachmentDropListener defaultDropListener;	451	private TaskAttachmentDropListener defaultDropListener;
451		452
		453	private CommonTextSupport textSupport;
		454
452	// TODO 3.1 define constructor for setting id and label	455	// TODO 3.1 define constructor for setting id and label
453	public AbstractTaskEditorPage(TaskEditor editor, String connectorKind) {	456	public AbstractTaskEditorPage(TaskEditor editor, String connectorKind) {
454	super(editor, "id", "label"); //$NON-NLS-1$ //$NON-NLS-2$	457	super(editor, "id", "label"); //$NON-NLS-1$ //$NON-NLS-2$
Lines 520-527 Link Here
520	}	523	}
521		524
522	AttributeEditorToolkit createAttributeEditorToolkit() {	525	AttributeEditorToolkit createAttributeEditorToolkit() {
523	IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);	526	return new AttributeEditorToolkit(textSupport);
524	return new AttributeEditorToolkit(handlerService);
525	}	527	}
526		528
527	@Override	529	@Override
Lines 620-626 Link Here
620	attributeEditorToolkit = createAttributeEditorToolkit();	622	attributeEditorToolkit = createAttributeEditorToolkit();
621	Assert.isNotNull(attributeEditorToolkit);	623	Assert.isNotNull(attributeEditorToolkit);
622	attributeEditorToolkit.setMenu(editorComposite.getMenu());	624	attributeEditorToolkit.setMenu(editorComposite.getMenu());
623	attributeEditorToolkit.setSelectionChangedListener(this);
624	attributeEditorFactory.setEditorToolkit(attributeEditorToolkit);	625	attributeEditorFactory.setEditorToolkit(attributeEditorToolkit);
625		626
626	createParts();	627	createParts();
Lines 1113-1118 Link Here
1113	this.task = taskEditorInput.getTask();	1114	this.task = taskEditorInput.getTask();
1114	this.defaultSelection = new StructuredSelection(task);	1115	this.defaultSelection = new StructuredSelection(task);
1115	this.lastSelection = defaultSelection;	1116	this.lastSelection = defaultSelection;
		1117	IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);
		1118	this.textSupport = new CommonTextSupport(handlerService);
1116		1119
1117	initModel(taskEditorInput);	1120	initModel(taskEditorInput);
1118		1121
Lines 1424-1427 Link Here
1424	}	1427	}
1425	}	1428	}
1426		1429
		1430	/**
		1431	* @since 3.1
		1432	*/
		1433	public CommonTextSupport getTextSupport() {
		1434	return textSupport;
		1435	}
		1436
1427	}	1437	}





package org.eclipse.mylyn.tasks.ui.editors;

import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.fieldassist.ComboContentAdapter;
import org.eclipse.jface.fieldassist.ContentProposalAdapter;
import org.eclipse.jface.fieldassist.ControlDecoration;

import org.eclipse.jface.fieldassist.IContentProposalProvider;
import org.eclipse.jface.fieldassist.IControlContentAdapter;
import org.eclipse.jface.fieldassist.TextContentAdapter;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;
import org.eclipse.mylyn.internal.tasks.ui.PersonProposalLabelProvider;
import org.eclipse.mylyn.internal.tasks.ui.PersonProposalProvider;

import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.ActiveShellExpression;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.fieldassist.ContentAssistCommandAdapter;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.keys.IBindingService;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
import org.eclipse.ui.themes.IThemeManager;

// TODO EDITOR rename to AttributeUiToolkit?
public class AttributeEditorToolkit {

	private class StyledTextFocusListener implements FocusListener {

		private final boolean spellCheck;

		private final SourceViewer viewer;

		public StyledTextFocusListener(SourceViewer viewer, boolean spellCheck) {
			this.viewer = viewer;
			this.spellCheck = spellCheck;
		}

		public void focusGained(FocusEvent e) {
			if (selectionChangedListener != null) {
				selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, viewer.getSelection()));
			}
			activateHandlers(viewer, spellCheck);
		}

		public void focusLost(FocusEvent e) {
			deactivateHandlers();
			if (selectionChangedListener != null) {
				// make sure selection no text is selected when control looses focus
				StyledText st = (StyledText) e.widget;
				st.setSelectionRange(st.getCaretOffset(), 0);
				// update action enablement
				selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, StructuredSelection.EMPTY));
			}
		}

	}

	private final Color colorIncoming;

	public IHandlerActivation contentAssistHandlerActivation;

	private final IHandlerService handlerService;

	private Menu menu;

	private AbstractRenderingEngine renderingEngine;

	private final CommonTextSupport textSupport;

	@Deprecated
	public IHandlerActivation contentAssistHandlerActivation;

	AttributeEditorToolkit(CommonTextSupport textSupport) {
		this.textSupport = textSupport;
		IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();
		colorIncoming = themeManager.getCurrentTheme().getColorRegistry().get(CommonThemes.COLOR_INCOMING_BACKGROUND);
	}

	private IHandlerActivation activateHandler(SourceViewer viewer, int operation, String actionDefinitionId) {
		IHandler handler = createActionHandler(viewer, operation, actionDefinitionId);
		return handlerService.activateHandler(actionDefinitionId, handler, //
				new ActiveShellExpression(viewer.getTextWidget().getShell()));
	}

	private void activateHandlers(SourceViewer viewer, boolean spellCheck) {
		deactivateHandlers();
		if (spellCheck) {
			quickAssistHandlerActivation = activateHandler(viewer, ISourceViewer.QUICK_ASSIST,
					ITextEditorActionDefinitionIds.QUICK_ASSIST);
		}
		contentAssistHandlerActivation = activateHandler(viewer, ISourceViewer.CONTENTASSIST_PROPOSALS,
				ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);

	}

	public void adapt(AbstractAttributeEditor editor) {
		if (editor.getControl() instanceof Text || editor.getControl() instanceof CCombo) {
			Control control = editor.getControl();

			RichTextAttributeEditor richTextEditor = (RichTextAttributeEditor) editor;
			boolean spellCheck = hasSpellChecking(editor.getTaskAttribute());
			final SourceViewer viewer = richTextEditor.getViewer();
			textSupport.install(viewer, spellCheck);
			if (selectionChangedListener != null) {
				viewer.addSelectionChangedListener(selectionChangedListener);
				viewer.addTextListener(new ITextListener() {
					public void textChanged(TextEvent event) {
						if (selectionChangedListener != null) {
							selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer,
									viewer.getSelection()));
						}
					}
				});
			}
			if (!editor.isReadOnly() && richTextEditor.getMode() == Mode.TASK_RELATION) {
				installContentAssistControlDecoration(viewer.getControl());
			}
			installMenu(viewer.getControl());
			EditorUtil.setTextViewer(editor.getControl(), viewer);
		} else {
			final TextViewer viewer = EditorUtil.getTextViewer(editor.getControl());
			if (viewer != null) {
				textSupport.install(viewer, false);
					viewer.addSelectionChangedListener(selectionChangedListener);
					viewer.addTextListener(new ITextListener() {
						public void textChanged(TextEvent event) {
							if (selectionChangedListener != null) {
								selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer,
										viewer.getSelection()));
							}
						}
					});
				}
				installMenu(viewer.getControl());
			}
		}

		return controlDecoration;
	}

	private IHandler createActionHandler(final SourceViewer viewer, final int operation, String actionDefinitionId) {
		Action quickFixAction = new Action() {
			@Override
			public void run() {
				if (viewer.canDoOperation(operation)) {
					viewer.doOperation(operation);
				}
			}
		};
		quickFixAction.setActionDefinitionId(actionDefinitionId);
		return new ActionHandler(quickFixAction);
	}

	/**
	 * Creates an IContentProposalProvider to provide content assist proposals for the given attribute.
	 * 

		return new PersonProposalLabelProvider();
	}

	private void deactivateHandlers() {
		if (quickAssistHandlerActivation != null) {
			handlerService.deactivateHandler(quickAssistHandlerActivation);
			quickAssistHandlerActivation = null;
		}
		if (contentAssistHandlerActivation != null) {
			handlerService.deactivateHandler(contentAssistHandlerActivation);
			contentAssistHandlerActivation = null;
		}
	}

	void dispose() {
		// FIXME textSupport.deactivateHandlers();
	}

	public Color getColorIncoming() {

		return renderingEngine;
	}

	ISelectionChangedListener getSelectionChangedListener() {
		return selectionChangedListener;
	}

	/**
	 * Called to check if there's content assist available for the given attribute.
	 * 

		this.menu = menu;
	}

	void setSelectionChangedListener(ISelectionChangedListener selectionListener) {
		this.selectionChangedListener = selectionListener;
	}

	public void setRenderingEngine(AbstractRenderingEngine renderingEngine) {
		this.renderingEngine = renderingEngine;
	}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.editors;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPart;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.internal.EditorAreaHelper;
import org.eclipse.ui.internal.WorkbenchPage;

/**
 * @author Steffen Pingel
 */
public class TaskEditorNotesPart extends AbstractTaskEditorPart {

	private String value;

	private AbstractTask task;

	private SourceViewer noteEditor;

	public TaskEditorNotesPart() {
		setPartName(Messages.TaskPlanningEditor_Notes);
	}

	@Override
	public void initialize(AbstractTaskEditorPage taskEditorPage) {
		super.initialize(taskEditorPage);
		task = (AbstractTask) taskEditorPage.getTask();
	}

	private boolean notesEqual() {
		if (task.getNotes() == null && value == null) {
			return true;
		}

		if (task.getNotes() != null && value != null) {
			return task.getNotes().equals(value);
		}
		return false;
	}

	@Override
	public void commit(boolean onSave) {
		Assert.isNotNull(task);

		if (!notesEqual()) {
			task.setNotes(value);
			// XXX REFRESH THE TASLKIST
		}

		super.commit(onSave);
	}

	@Override
	public void createControl(Composite parent, FormToolkit toolkit) {
		this.value = task.getNotes();
		if (this.value == null) {
			this.value = "";
		}

		Section section = createSection(parent, toolkit, this.value != null && this.value.length() > 0);

		Composite composite = toolkit.createComposite(section);
		GridLayout layout = new GridLayout();
		layout.numColumns = 1;
		composite.setLayout(layout);

		noteEditor = new SourceViewer(parent, null, SWT.FLAT | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		noteEditor.configure(new RepositoryTextViewerConfiguration(getModel().getTaskRepository(), true));
		getTaskEditorPage().getTextSupport().configure(noteEditor, new Document(this.value), true);
		noteEditor.addTextListener(new ITextListener() {
			public void textChanged(TextEvent event) {
				TaskEditorNotesPart.this.value = noteEditor.getTextWidget().getText();
				markDirty();
			}
		});

		final GridData gd = new GridData(GridData.FILL_BOTH);
		int widthHint = 0;

		if (getManagedForm() != null && getManagedForm().getForm() != null) {
			widthHint = getManagedForm().getForm().getClientArea().width - 90;
		}
		if (widthHint <= 0 && getTaskEditorPage().getEditor().getEditorSite() != null
				&& getTaskEditorPage().getEditor().getEditorSite().getPage() != null) {
			EditorAreaHelper editorManager = ((WorkbenchPage) getTaskEditorPage().getEditor().getEditorSite().getPage()).getEditorPresentation();
			if (editorManager != null && editorManager.getLayoutPart() != null) {
				widthHint = editorManager.getLayoutPart().getControl().getBounds().width - 90;
			}
		}

		if (widthHint <= 0) {
			widthHint = 100;
		}

		gd.widthHint = widthHint;
		gd.minimumHeight = 100;
		gd.grabExcessHorizontalSpace = true;

		noteEditor.getControl().setLayoutData(gd);
		noteEditor.getControl().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
		noteEditor.setEditable(true);

		toolkit.paintBordersFor(composite);
		section.setClient(composite);
		setSection(toolkit, section);
	}

}

Return to bug 234044

Added Link Here

(-)src/org/eclipse/mylyn/internal/provisional/commons/ui/WorkbenchActionSupport.java (+253 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 Tasktop Technologies and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Tasktop Technologies - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.provisional.commons.ui;
13
14	import org.eclipse.jface.action.Action;
15	import org.eclipse.jface.action.IMenuManager;
16	import org.eclipse.jface.action.Separator;
17	import org.eclipse.jface.text.TextSelection;
18	import org.eclipse.jface.viewers.ISelection;
19	import org.eclipse.jface.viewers.ISelectionChangedListener;
20	import org.eclipse.jface.viewers.SelectionChangedEvent;
21	import org.eclipse.swt.widgets.Control;
22	import org.eclipse.swt.widgets.Display;
23	import org.eclipse.ui.IActionBars;
24	import org.eclipse.ui.ISharedImages;
25	import org.eclipse.ui.IWorkbenchWindow;
26	import org.eclipse.ui.PlatformUI;
27	import org.eclipse.ui.actions.ActionFactory;
28	import org.eclipse.ui.internal.WorkbenchImages;
29	import org.eclipse.ui.internal.WorkbenchMessages;
30	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
31
32	/**
33	* @author Mik Kersten
34	* @author Rob Elves
35	* @author Steffen Pingel
36	*/
37	@SuppressWarnings("restriction")
38	public class WorkbenchActionSupport implements ISelectionChangedListener {
39
40	private class GlobalAction extends Action {
41
42	private final String actionId;
43
44	public GlobalAction(String actionId) {
45	this.actionId = actionId;
46	}
47
48	@Override
49	public void run() {
50	if (callback != null) {
51	callback.doAction(actionId, callback.getFocusControl());
52	updateActions(callback.getSelection());
53	}
54	}
55
56	public void selectionChanged(ISelection selection) {
57	if (callback != null) {
58	setEnabled(callback.canPerformAction(actionId, callback.getFocusControl()));
59	} else {
60	setEnabled(false);
61	}
62	}
63	}
64
65	public static class WorkbenchActionCallback {
66
67	public boolean canPerformAction(String actionId, Control control) {
68	return CommonTextSupport.canPerformAction(actionId, control);
69	}
70
71	public void doAction(String actionId, Control control) {
72	CommonTextSupport.doAction(actionId, control);
73	}
74
75	public Control getFocusControl() {
76	return Display.getDefault().getFocusControl();
77	}
78
79	public ISelection getSelection() {
80	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
81	if (window != null && window.getSelectionService() != null) {
82	return window.getSelectionService().getSelection();
83	}
84	return null;
85	}
86
87	}
88
89	private WorkbenchActionCallback callback;
90
91	private final GlobalAction copyAction;
92
93	private final GlobalAction cutAction;
94
95	private final GlobalAction findAction;
96
97	private final GlobalAction pasteAction;
98
99	private final GlobalAction redoAction;
100
101	private final GlobalAction selectAllAction;
102
103	private final GlobalAction undoAction;
104
105	public WorkbenchActionSupport() {
106	cutAction = new GlobalAction(ActionFactory.CUT.getId());
107	cutAction.setText(WorkbenchMessages.Workbench_cut);
108	cutAction.setToolTipText(WorkbenchMessages.Workbench_cutToolTip);
109	cutAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
110	cutAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
111	cutAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT_DISABLED));
112	cutAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.CUT);
113
114	pasteAction = new GlobalAction(ActionFactory.PASTE.getId());
115	pasteAction.setText(WorkbenchMessages.Workbench_paste);
116	pasteAction.setToolTipText(WorkbenchMessages.Workbench_pasteToolTip);
117	pasteAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
118	pasteAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
119	pasteAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED));
120	pasteAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);
121
122	copyAction = new GlobalAction(ActionFactory.COPY.getId());
123	copyAction.setText(WorkbenchMessages.Workbench_copy);
124	copyAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
125	copyAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
126	copyAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));
127	copyAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.COPY);
128
129	undoAction = new GlobalAction(ActionFactory.UNDO.getId());
130	undoAction.setText(WorkbenchMessages.Workbench_undo);
131	undoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
132	undoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
133	undoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_DISABLED));
134	undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);
135
136	redoAction = new GlobalAction(ActionFactory.REDO.getId());
137	redoAction.setText(WorkbenchMessages.Workbench_redo);
138	redoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
139	redoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
140	redoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_DISABLED));
141	redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);
142
143	selectAllAction = new GlobalAction(ActionFactory.SELECT_ALL.getId());
144	selectAllAction.setText(WorkbenchMessages.Workbench_selectAll);
145	selectAllAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.SELECT_ALL);
146	selectAllAction.setEnabled(true);
147
148	findAction = new GlobalAction(ActionFactory.FIND.getId());
149	findAction.setText(WorkbenchMessages.Workbench_findReplace);
150	findAction.setImageDescriptor(CommonImages.FIND);
151	findAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.FIND_REPLACE);
152	}
153
154	public void contributeActions(IMenuManager manager) {
155	manager.add(undoAction);
156	manager.add(redoAction);
157	manager.add(new Separator());
158	manager.add(cutAction);
159	manager.add(copyAction);
160	manager.add(pasteAction);
161	manager.add(selectAllAction);
162	manager.add(new Separator());
163	}
164
165	public void forceEditActionsEnabled() {
166	cutAction.setEnabled(true);
167	copyAction.setEnabled(true);
168	pasteAction.setEnabled(true);
169	selectAllAction.setEnabled(true);
170	undoAction.setEnabled(false);
171	redoAction.setEnabled(false);
172	}
173
174	public WorkbenchActionCallback getCallback() {
175	return callback;
176	}
177
178	public Action getCopyAction() {
179	return copyAction;
180	}
181
182	public Action getCutAction() {
183	return cutAction;
184	}
185
186	public Action getFindAction() {
187	return findAction;
188	}
189
190	public Action getPasteAction() {
191	return pasteAction;
192	}
193
194	public Action getRedoAction() {
195	return redoAction;
196	}
197
198	public Action getSelectAllAction() {
199	return selectAllAction;
200	}
201
202	public Action getUndoAction() {
203	return undoAction;
204	}
205
206	public void install(IActionBars bars) {
207	bars.setGlobalActionHandler(ActionFactory.CUT.getId(), cutAction);
208	bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), pasteAction);
209	bars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction);
210	bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);
211	bars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);
212	bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), selectAllAction);
213	bars.setGlobalActionHandler(ActionFactory.FIND.getId(), findAction);
214	bars.updateActionBars();
215	}
216
217	public void selectionChanged(SelectionChangedEvent event) {
218	ISelection selection = event.getSelection();
219	if (selection instanceof TextSelection) {
220	// only update global actions
221	updateActions(event.getSelection());
222	} else if (selection.isEmpty()) {
223	// XXX a styled text widget has lost focus, re-enable all edit actions
224	forceEditActionsEnabled();
225	}
226	}
227
228	public void setCallback(WorkbenchActionCallback callback) {
229	this.callback = callback;
230	}
231
232	public void uninstall(IActionBars bars) {
233	bars.setGlobalActionHandler(ActionFactory.CUT.getId(), null);
234	bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), null);
235	bars.setGlobalActionHandler(ActionFactory.COPY.getId(), null);
236	bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), null);
237	bars.setGlobalActionHandler(ActionFactory.REDO.getId(), null);
238	bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null);
239	bars.setGlobalActionHandler(ActionFactory.FIND.getId(), null);
240	bars.updateActionBars();
241	}
242
243	public void updateActions(ISelection selection) {
244	cutAction.selectionChanged(selection);
245	copyAction.selectionChanged(selection);
246	pasteAction.selectionChanged(selection);
247	undoAction.selectionChanged(selection);
248	redoAction.selectionChanged(selection);
249	selectAllAction.selectionChanged(selection);
250	findAction.selectionChanged(selection);
251	}
252
253	}

Lines 24-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java (-1 / +32 lines)
24	import org.eclipse.jface.action.IToolBarManager;	24	import org.eclipse.jface.action.IToolBarManager;
25	import org.eclipse.jface.dialogs.MessageDialog;	25	import org.eclipse.jface.dialogs.MessageDialog;
26	import org.eclipse.jface.layout.GridDataFactory;	26	import org.eclipse.jface.layout.GridDataFactory;
		27	import org.eclipse.jface.text.Document;
27	import org.eclipse.jface.text.ITextListener;	28	import org.eclipse.jface.text.ITextListener;
28	import org.eclipse.jface.text.TextEvent;	29	import org.eclipse.jface.text.TextEvent;
29	import org.eclipse.jface.text.TextViewer;	30	import org.eclipse.jface.text.TextViewer;
		31	import org.eclipse.jface.text.source.SourceViewer;
30	import org.eclipse.jface.viewers.StructuredSelection;	32	import org.eclipse.jface.viewers.StructuredSelection;
31	import org.eclipse.mylyn.commons.core.StatusHandler;	33	import org.eclipse.mylyn.commons.core.StatusHandler;
32	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;	34	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
		35	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
33	import org.eclipse.mylyn.internal.provisional.commons.ui.DatePicker;	36	import org.eclipse.mylyn.internal.provisional.commons.ui.DatePicker;
34	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;	37	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
35	import org.eclipse.mylyn.internal.tasks.core.DayDateRange;	38	import org.eclipse.mylyn.internal.tasks.core.DayDateRange;
Lines 77-85 Link Here
77	import org.eclipse.swt.widgets.Label;	80	import org.eclipse.swt.widgets.Label;
78	import org.eclipse.swt.widgets.Spinner;	81	import org.eclipse.swt.widgets.Spinner;
79	import org.eclipse.swt.widgets.Text;	82	import org.eclipse.swt.widgets.Text;
		83	import org.eclipse.ui.IEditorInput;
		84	import org.eclipse.ui.IEditorSite;
80	import org.eclipse.ui.PlatformUI;	85	import org.eclipse.ui.PlatformUI;
81	import org.eclipse.ui.forms.IFormColors;	86	import org.eclipse.ui.forms.IFormColors;
82	import org.eclipse.ui.forms.IManagedForm;	87	import org.eclipse.ui.forms.IManagedForm;
		88	import org.eclipse.ui.forms.editor.FormPage;
83	import org.eclipse.ui.forms.events.ExpansionEvent;	89	import org.eclipse.ui.forms.events.ExpansionEvent;
84	import org.eclipse.ui.forms.events.HyperlinkAdapter;	90	import org.eclipse.ui.forms.events.HyperlinkAdapter;
85	import org.eclipse.ui.forms.events.HyperlinkEvent;	91	import org.eclipse.ui.forms.events.HyperlinkEvent;
Lines 90-101 Link Here
90	import org.eclipse.ui.forms.widgets.ImageHyperlink;	96	import org.eclipse.ui.forms.widgets.ImageHyperlink;
91	import org.eclipse.ui.forms.widgets.ScrolledForm;	97	import org.eclipse.ui.forms.widgets.ScrolledForm;
92	import org.eclipse.ui.forms.widgets.Section;	98	import org.eclipse.ui.forms.widgets.Section;
		99	import org.eclipse.ui.handlers.IHandlerService;
93		100
94	/**	101	/**
95	* @author Mik Kersten	102	* @author Mik Kersten
96	* @author Rob Elves	103	* @author Rob Elves
97	*/	104	*/
98	public class TaskPlanningEditor extends TaskFormPage {	105	public class TaskPlanningEditor extends FormPage {
99		106
100	private static final String RESET = Messages.TaskPlanningEditor_Reset;	107	private static final String RESET = Messages.TaskPlanningEditor_Reset;
101		108
Lines 182-193 Link Here
182		189
183	private ITaskActivityListener timingListener;	190	private ITaskActivityListener timingListener;
184		191
		192	private boolean isDirty;
		193
		194	private CommonTextSupport textSupport;
		195
185	public TaskPlanningEditor(TaskEditor editor) {	196	public TaskPlanningEditor(TaskEditor editor) {
186	super(editor, ITasksUiConstants.ID_PAGE_PLANNING, Messages.TaskPlanningEditor_Planning);	197	super(editor, ITasksUiConstants.ID_PAGE_PLANNING, Messages.TaskPlanningEditor_Planning);
187	this.parentEditor = editor;	198	this.parentEditor = editor;
188	TasksUiInternal.getTaskList().addChangeListener(TASK_LIST_LISTENER);	199	TasksUiInternal.getTaskList().addChangeListener(TASK_LIST_LISTENER);
189	}	200	}
190		201
		202	@Override
		203	public void init(IEditorSite site, IEditorInput input) {
		204	super.init(site, input);
		205	this.textSupport = new CommonTextSupport((IHandlerService) getSite().getService(IHandlerService.class));
		206	this.textSupport.setSelectionChangedListener((TaskEditorActionContributor) getEditorSite().getActionBarContributor());
		207	}
		208
191	/**	209	/**
192	* Override for customizing the tool bar.	210	* Override for customizing the tool bar.
193	*/	211	*/
Lines 564-569 Link Here
564	toolkit.paintBordersFor(statusComposite);	582	toolkit.paintBordersFor(statusComposite);
565	}	583	}
566		584
		585	private TextViewer addTextEditor(TaskRepository repository, Composite parent, String text, boolean spellCheck,
		586	int style) {
		587	SourceViewer viewer = new SourceViewer(parent, null, style);
		588	viewer.configure(new RepositoryTextViewerConfiguration(repository, spellCheck));
		589	textSupport.configure(viewer, new Document(text), spellCheck);
		590	return viewer;
		591	}
		592
		593	private void markDirty(boolean dirty) {
		594	isDirty = dirty;
		595	getManagedForm().dirtyStateChanged();
		596	}
		597
567	/**	598	/**
568	* Attempts to set the task pageTitle to the title from the specified url	599	* Attempts to set the task pageTitle to the title from the specified url
569	*/	600	*/

Lines 29-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorActionContributor.java (-186 / +103 lines)
29	import org.eclipse.jface.viewers.IStructuredSelection;	29	import org.eclipse.jface.viewers.IStructuredSelection;
30	import org.eclipse.jface.viewers.SelectionChangedEvent;	30	import org.eclipse.jface.viewers.SelectionChangedEvent;
31	import org.eclipse.jface.viewers.StructuredSelection;	31	import org.eclipse.jface.viewers.StructuredSelection;
32	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;	32	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchActionSupport;
		33	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchActionSupport.WorkbenchActionCallback;
33	import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;	34	import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
34	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	35	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
35	import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;	36	import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;
Lines 51-70 Link Here
51	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;	52	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
52	import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;	53	import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
53	import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;	54	import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
		55	import org.eclipse.swt.widgets.Control;
54	import org.eclipse.ui.IActionBars;	56	import org.eclipse.ui.IActionBars;
55	import org.eclipse.ui.IEditorInput;	57	import org.eclipse.ui.IEditorInput;
56	import org.eclipse.ui.IEditorPart;	58	import org.eclipse.ui.IEditorPart;
57	import org.eclipse.ui.ISharedImages;
58	import org.eclipse.ui.IWorkbenchActionConstants;	59	import org.eclipse.ui.IWorkbenchActionConstants;
59	import org.eclipse.ui.IWorkbenchPage;	60	import org.eclipse.ui.IWorkbenchPage;
60	import org.eclipse.ui.PlatformUI;	61	import org.eclipse.ui.PlatformUI;
61	import org.eclipse.ui.actions.ActionFactory;
62	import org.eclipse.ui.forms.editor.IFormPage;	62	import org.eclipse.ui.forms.editor.IFormPage;
63	import org.eclipse.ui.internal.WorkbenchImages;
64	import org.eclipse.ui.internal.WorkbenchMessages;
65	import org.eclipse.ui.part.MultiPageEditorActionBarContributor;	63	import org.eclipse.ui.part.MultiPageEditorActionBarContributor;
66	import org.eclipse.ui.progress.IProgressService;	64	import org.eclipse.ui.progress.IProgressService;
67	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
68		65
69	/**	66	/**
70	* @author Mik Kersten	67	* @author Mik Kersten
Lines 74-163 Link Here
74	public class TaskEditorActionContributor extends MultiPageEditorActionBarContributor implements	71	public class TaskEditorActionContributor extends MultiPageEditorActionBarContributor implements
75	ISelectionChangedListener {	72	ISelectionChangedListener {
76		73
77	private TaskEditor editor;	74	private class EditorPageCallback extends WorkbenchActionCallback {
78		75
79	private final OpenWithBrowserAction openWithBrowserAction = new OpenWithBrowserAction();	76	@Override
		77	public boolean canPerformAction(String actionId, Control control) {
		78	IFormPage activePage = getActivePage();
		79	if (activePage instanceof AbstractTaskEditorPage) {
		80	AbstractTaskEditorPage page = (AbstractTaskEditorPage) activePage;
		81	return page.canPerformAction(actionId);
		82	} else {
		83	WorkbenchActionCallback textSupport = (WorkbenchActionCallback) activePage.getAdapter(WorkbenchActionCallback.class);
		84	if (textSupport != null) {
		85	return textSupport.canPerformAction(actionId, control);
		86	} else {
		87	return super.canPerformAction(actionId, control);
		88	}
		89	}
		90	}
80		91
81	private final CopyTaskDetailsAction copyTaskDetailsAction = new CopyTaskDetailsAction();	92	@Override
		93	public void doAction(String actionId, Control control) {
		94	IFormPage activePage = getActivePage();
		95	if (activePage instanceof AbstractTaskEditorPage) {
		96	AbstractTaskEditorPage page = (AbstractTaskEditorPage) activePage;
		97	page.doAction(actionId);
		98	} else {
		99	WorkbenchActionCallback textSupport = (WorkbenchActionCallback) activePage.getAdapter(WorkbenchActionCallback.class);
		100	if (textSupport != null) {
		101	textSupport.doAction(actionId, control);
		102	} else {
		103	super.doAction(actionId, control);
		104	}
		105	}
		106	}
82		107
83	private final SynchronizeEditorAction synchronizeEditorAction = new SynchronizeEditorAction();	108	@Override
		109	public Control getFocusControl() {
		110	IFormPage page = getActivePage();
		111	return EditorUtil.getFocusControl(page);
		112	}
84		113
85	private final ShowInTaskListAction showInTaskListAction = new ShowInTaskListAction();	114	@Override
		115	public ISelection getSelection() {
		116	return TaskEditorActionContributor.this.getSelection();
		117	}
86		118
87	private final NewTaskFromSelectionAction newTaskFromSelectionAction = new NewTaskFromSelectionAction();	119	}
88		120
89	private final GlobalAction cutAction;	121	private TaskEditor editor;
90		122
91	private final GlobalAction undoAction;	123	private final OpenWithBrowserAction openWithBrowserAction = new OpenWithBrowserAction();
92		124
93	private final GlobalAction redoAction;	125	private final CopyTaskDetailsAction copyTaskDetailsAction = new CopyTaskDetailsAction();
94		126
95	private final GlobalAction copyAction;	127	private final SynchronizeEditorAction synchronizeEditorAction = new SynchronizeEditorAction();
96		128
97	private final GlobalAction pasteAction;	129	private final ShowInTaskListAction showInTaskListAction = new ShowInTaskListAction();
98		130
99	private final GlobalAction selectAllAction;	131	private final NewTaskFromSelectionAction newTaskFromSelectionAction = new NewTaskFromSelectionAction();
100		132
101	private final GlobalAction findAction;	133	private final WorkbenchActionSupport actionSupport;
102		134
103	public TaskEditorActionContributor() {	135	public TaskEditorActionContributor() {
104	cutAction = new GlobalAction(ActionFactory.CUT.getId());	136	actionSupport = new WorkbenchActionSupport();
105	cutAction.setText(WorkbenchMessages.Workbench_cut);	137	actionSupport.setCallback(new EditorPageCallback());
106	cutAction.setToolTipText(WorkbenchMessages.Workbench_cutToolTip);
107	cutAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
108	cutAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT));
109	cutAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_CUT_DISABLED));
110	cutAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.CUT);
111
112	pasteAction = new GlobalAction(ActionFactory.PASTE.getId());
113	pasteAction.setText(WorkbenchMessages.Workbench_paste);
114	pasteAction.setToolTipText(WorkbenchMessages.Workbench_pasteToolTip);
115	pasteAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
116	pasteAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE));
117	pasteAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED));
118	pasteAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);
119
120	copyAction = new GlobalAction(ActionFactory.COPY.getId());
121	copyAction.setText(WorkbenchMessages.Workbench_copy);
122	copyAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
123	copyAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
124	copyAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));
125	copyAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.COPY);
126
127	undoAction = new GlobalAction(ActionFactory.UNDO.getId());
128	undoAction.setText(WorkbenchMessages.Workbench_undo);
129	undoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
130	undoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO));
131	undoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_UNDO_DISABLED));
132	undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);
133
134	redoAction = new GlobalAction(ActionFactory.REDO.getId());
135	redoAction.setText(WorkbenchMessages.Workbench_redo);
136	redoAction.setImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
137	redoAction.setHoverImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO));
138	redoAction.setDisabledImageDescriptor(WorkbenchImages.getImageDescriptor(ISharedImages.IMG_TOOL_REDO_DISABLED));
139	redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);
140
141	selectAllAction = new GlobalAction(ActionFactory.SELECT_ALL.getId());
142	selectAllAction.setText(WorkbenchMessages.Workbench_selectAll);
143	selectAllAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.SELECT_ALL);
144	selectAllAction.setEnabled(true);
145
146	findAction = new GlobalAction(ActionFactory.FIND.getId());
147	findAction.setText(Messages.TaskEditorActionContributor_Find);
148	findAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.FIND_REPLACE);
149	findAction.setImageDescriptor(CommonImages.FIND);
150	}	138	}
151		139
152	public void addClipboardActions(IMenuManager manager) {	140	public void addClipboardActions(IMenuManager manager) {
153	manager.add(undoAction);	141	manager.add(actionSupport.getUndoAction());
154	manager.add(redoAction);	142	manager.add(actionSupport.getRedoAction());
155	manager.add(new Separator());	143	manager.add(new Separator());
156	manager.add(cutAction);	144	manager.add(actionSupport.getCutAction());
157	manager.add(copyAction);	145	manager.add(actionSupport.getCopyAction());
158	manager.add(copyTaskDetailsAction);	146	manager.add(copyTaskDetailsAction);
159	manager.add(pasteAction);	147	manager.add(actionSupport.getPasteAction());
160	manager.add(selectAllAction);	148	manager.add(actionSupport.getSelectAllAction());
161	manager.add(newTaskFromSelectionAction);	149	manager.add(newTaskFromSelectionAction);
162	manager.add(new Separator());	150	manager.add(new Separator());
163	}	151	}
Lines 257-289 Link Here
257	manager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));	245	manager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
258	}	246	}
259		247
260	private void moveToCategory(AbstractTaskCategory category) {	248	@Override
261	IEditorInput input = getEditor().getEditorInput();	249	public void contributeToCoolBar(ICoolBarManager cbm) {
262	if (input instanceof TaskEditorInput) {
263	TaskEditorInput repositoryTaskEditorInput = (TaskEditorInput) input;
264	final IProgressService svc = PlatformUI.getWorkbench().getProgressService();
265	final AddExistingTaskJob job = new AddExistingTaskJob(repositoryTaskEditorInput.getTaskRepository(),
266	repositoryTaskEditorInput.getTask().getTaskId(), category);
267	job.schedule();
268	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
269	public void run() {
270	svc.showInDialog(getEditor().getSite().getShell(), job);
271	}
272	});
273	}
274	}
275
276	public void updateSelectableActions(ISelection selection) {
277	if (editor != null) {
278	cutAction.selectionChanged(selection);
279	copyAction.selectionChanged(selection);
280	pasteAction.selectionChanged(selection);
281	undoAction.selectionChanged(selection);
282	redoAction.selectionChanged(selection);
283	selectAllAction.selectionChanged(selection);
284	newTaskFromSelectionAction.selectionChanged(selection);
285	findAction.selectionChanged(selection);
286	}
287	}	250	}
288		251
289	@Override	252	@Override
Lines 298-415 Link Here
298	public void contributeToToolBar(IToolBarManager tbm) {	261	public void contributeToToolBar(IToolBarManager tbm) {
299	}	262	}
300		263
301	@Override	264	public void forceActionsEnabled() {
302	public void contributeToCoolBar(ICoolBarManager cbm) {	265	actionSupport.forceEditActionsEnabled();
303	}	266	}
304		267
305	@Override	268	private IFormPage getActivePage() {
306	public void init(IActionBars bars, IWorkbenchPage page) {	269	return (editor != null) ? editor.getActivePageInstance() : null;
307	super.init(bars, page);
308	registerGlobalHandlers(bars);
309	findAction.selectionChanged(StructuredSelection.EMPTY);
310	}	270	}
311		271
312	public TaskEditor getEditor() {	272	public TaskEditor getEditor() {
313	return editor;	273	return editor;
314	}	274	}
315		275
316	@Override	276	public ISelection getSelection() {
317	public void setActiveEditor(IEditorPart activeEditor) {	277	if (editor != null && editor.getSite().getSelectionProvider() != null) {
318	if (activeEditor instanceof TaskEditor) {	278	return editor.getSite().getSelectionProvider().getSelection();
319	this.editor = (TaskEditor) activeEditor;
320	updateSelectableActions(getSelection());
321	} else {	279	} else {
322	this.editor = null;	280	return StructuredSelection.EMPTY;
323	}	281	}
324	}	282	}
325		283
326	@Override	284	@Override
327	public void setActivePage(IEditorPart activePage) {	285	public void init(IActionBars bars, IWorkbenchPage page) {
328	updateSelectableActions(getSelection());	286	super.init(bars, page);
329	}	287	actionSupport.install(bars);
330
331	public void selectionChanged(SelectionChangedEvent event) {
332	updateSelectableActions(event.getSelection());
333	}	288	}
334		289
335	private class GlobalAction extends Action {	290	private void moveToCategory(AbstractTaskCategory category) {
336		291	IEditorInput input = getEditor().getEditorInput();
337	private final String actionId;	292	if (input instanceof TaskEditorInput) {
338		293	TaskEditorInput repositoryTaskEditorInput = (TaskEditorInput) input;
339	public GlobalAction(String actionId) {	294	final IProgressService svc = PlatformUI.getWorkbench().getProgressService();
340	this.actionId = actionId;	295	final AddExistingTaskJob job = new AddExistingTaskJob(repositoryTaskEditorInput.getTaskRepository(),
341	}	296	repositoryTaskEditorInput.getTask().getTaskId(), category);
342		297	job.schedule();
343	@Override	298	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
344	public void run() {	299	public void run() {
345	IFormPage page = getActivePage();	300	svc.showInDialog(getEditor().getSite().getShell(), job);
346	if (page instanceof TaskFormPage) {	301	}
347	TaskFormPage editor = (TaskFormPage) page;	302	});
348	editor.doAction(actionId);
349	} else if (page instanceof AbstractTaskEditorPage) {
350	AbstractTaskEditorPage editor = (AbstractTaskEditorPage) page;
351	editor.doAction(actionId);
352	} else {
353	EditorUtil.doAction(actionId, EditorUtil.getFocusControl(getActivePage()));
354	}
355	updateSelectableActions(getSelection());
356	}
357
358	public void selectionChanged(ISelection selection) {
359	IFormPage page = getActivePage();
360	if (page instanceof TaskFormPage) {
361	TaskFormPage editor = (TaskFormPage) page;
362	setEnabled(editor.canPerformAction(actionId));
363	} else if (page instanceof AbstractTaskEditorPage) {
364	AbstractTaskEditorPage editor = (AbstractTaskEditorPage) page;
365	setEnabled(editor.canPerformAction(actionId));
366	} else {
367	setEnabled(EditorUtil.canPerformAction(actionId, EditorUtil.getFocusControl(getActivePage())));
368	}
369	}	303	}
370	}	304	}
371		305
372	private void registerGlobalHandlers(IActionBars bars) {	306	public void selectionChanged(SelectionChangedEvent event) {
373	bars.setGlobalActionHandler(ActionFactory.CUT.getId(), cutAction);	307	actionSupport.selectionChanged(event);
374	bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), pasteAction);	308	newTaskFromSelectionAction.selectionChanged(event.getSelection());
375	bars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction);
376	bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);
377	bars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);
378	bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), selectAllAction);
379	bars.setGlobalActionHandler(ActionFactory.FIND.getId(), findAction);
380	bars.updateActionBars();
381	}
382
383	@SuppressWarnings("unused")
384	private void unregisterGlobalHandlers(IActionBars bars) {
385	bars.setGlobalActionHandler(ActionFactory.CUT.getId(), null);
386	bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), null);
387	bars.setGlobalActionHandler(ActionFactory.COPY.getId(), null);
388	bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), null);
389	bars.setGlobalActionHandler(ActionFactory.REDO.getId(), null);
390	bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null);
391	bars.setGlobalActionHandler(ActionFactory.FIND.getId(), null);
392	bars.updateActionBars();
393	}	309	}
394		310
395	public void forceActionsEnabled() {	311	@Override
396	cutAction.setEnabled(true);	312	public void setActiveEditor(IEditorPart activeEditor) {
397	copyAction.setEnabled(true);	313	if (activeEditor instanceof TaskEditor) {
398	pasteAction.setEnabled(true);	314	this.editor = (TaskEditor) activeEditor;
399	selectAllAction.setEnabled(true);	315	updateSelectableActions(getSelection());
400	undoAction.setEnabled(false);	316	} else {
401	redoAction.setEnabled(false);	317	this.editor = null;
		318	}
402	}	319	}
403		320
404	private IFormPage getActivePage() {	321	@Override
405	return (editor != null) ? editor.getActivePageInstance() : null;	322	public void setActivePage(IEditorPart activePage) {
		323	updateSelectableActions(getSelection());
406	}	324	}
407		325
408	private ISelection getSelection() {	326	public void updateSelectableActions(ISelection selection) {
409	if (editor != null && editor.getSite().getSelectionProvider() != null) {	327	if (editor != null) {
410	return editor.getSite().getSelectionProvider().getSelection();	328	actionSupport.updateActions(selection);
411	} else {	329	newTaskFromSelectionAction.selectionChanged(selection);
412	return StructuredSelection.EMPTY;
413	}	330	}
414	}	331	}
415		332

Lines 11-19 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AttributeEditorToolkit.java (-128 / +10 lines)
11		11
12	package org.eclipse.mylyn.tasks.ui.editors;	12	package org.eclipse.mylyn.tasks.ui.editors;
13		13
14	import org.eclipse.core.commands.IHandler;
15	import org.eclipse.jface.action.Action;
16	import org.eclipse.jface.commands.ActionHandler;
17	import org.eclipse.jface.fieldassist.ComboContentAdapter;	14	import org.eclipse.jface.fieldassist.ComboContentAdapter;
18	import org.eclipse.jface.fieldassist.ContentProposalAdapter;	15	import org.eclipse.jface.fieldassist.ContentProposalAdapter;
19	import org.eclipse.jface.fieldassist.ControlDecoration;	16	import org.eclipse.jface.fieldassist.ControlDecoration;
Lines 22-36 Link Here
22	import org.eclipse.jface.fieldassist.IContentProposalProvider;	19	import org.eclipse.jface.fieldassist.IContentProposalProvider;
23	import org.eclipse.jface.fieldassist.IControlContentAdapter;	20	import org.eclipse.jface.fieldassist.IControlContentAdapter;
24	import org.eclipse.jface.fieldassist.TextContentAdapter;	21	import org.eclipse.jface.fieldassist.TextContentAdapter;
25	import org.eclipse.jface.text.ITextListener;
26	import org.eclipse.jface.text.TextEvent;
27	import org.eclipse.jface.text.TextViewer;	22	import org.eclipse.jface.text.TextViewer;
28	import org.eclipse.jface.text.source.ISourceViewer;
29	import org.eclipse.jface.text.source.SourceViewer;	23	import org.eclipse.jface.text.source.SourceViewer;
30	import org.eclipse.jface.viewers.ILabelProvider;	24	import org.eclipse.jface.viewers.ILabelProvider;
31	import org.eclipse.jface.viewers.ISelectionChangedListener;	25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
32	import org.eclipse.jface.viewers.SelectionChangedEvent;
33	import org.eclipse.jface.viewers.StructuredSelection;
34	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;	26	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;
35	import org.eclipse.mylyn.internal.tasks.ui.PersonProposalLabelProvider;	27	import org.eclipse.mylyn.internal.tasks.ui.PersonProposalLabelProvider;
36	import org.eclipse.mylyn.internal.tasks.ui.PersonProposalProvider;	28	import org.eclipse.mylyn.internal.tasks.ui.PersonProposalProvider;
Lines 42-62 Link Here
42	import org.eclipse.osgi.util.NLS;	34	import org.eclipse.osgi.util.NLS;
43	import org.eclipse.swt.SWT;	35	import org.eclipse.swt.SWT;
44	import org.eclipse.swt.custom.CCombo;	36	import org.eclipse.swt.custom.CCombo;
45	import org.eclipse.swt.custom.StyledText;
46	import org.eclipse.swt.events.DisposeEvent;	37	import org.eclipse.swt.events.DisposeEvent;
47	import org.eclipse.swt.events.DisposeListener;	38	import org.eclipse.swt.events.DisposeListener;
48	import org.eclipse.swt.events.FocusEvent;
49	import org.eclipse.swt.events.FocusListener;
50	import org.eclipse.swt.graphics.Color;	39	import org.eclipse.swt.graphics.Color;
51	import org.eclipse.swt.widgets.Combo;	40	import org.eclipse.swt.widgets.Combo;
52	import org.eclipse.swt.widgets.Control;	41	import org.eclipse.swt.widgets.Control;
53	import org.eclipse.swt.widgets.Menu;	42	import org.eclipse.swt.widgets.Menu;
54	import org.eclipse.swt.widgets.Text;	43	import org.eclipse.swt.widgets.Text;
55	import org.eclipse.ui.ActiveShellExpression;
56	import org.eclipse.ui.PlatformUI;	44	import org.eclipse.ui.PlatformUI;
57	import org.eclipse.ui.fieldassist.ContentAssistCommandAdapter;	45	import org.eclipse.ui.fieldassist.ContentAssistCommandAdapter;
58	import org.eclipse.ui.handlers.IHandlerActivation;	46	import org.eclipse.ui.handlers.IHandlerActivation;
59	import org.eclipse.ui.handlers.IHandlerService;
60	import org.eclipse.ui.keys.IBindingService;	47	import org.eclipse.ui.keys.IBindingService;
61	import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;	48	import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
62	import org.eclipse.ui.themes.IThemeManager;	49	import org.eclipse.ui.themes.IThemeManager;
Lines 68-141 Link Here
68	// TODO EDITOR rename to AttributeUiToolkit?	55	// TODO EDITOR rename to AttributeUiToolkit?
69	public class AttributeEditorToolkit {	56	public class AttributeEditorToolkit {
70		57
71	private class StyledTextFocusListener implements FocusListener {
72
73	private final boolean spellCheck;
74
75	private final SourceViewer viewer;
76
77	public StyledTextFocusListener(SourceViewer viewer, boolean spellCheck) {
78	this.viewer = viewer;
79	this.spellCheck = spellCheck;
80	}
81
82	public void focusGained(FocusEvent e) {
83	if (selectionChangedListener != null) {
84	selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, viewer.getSelection()));
85	}
86	activateHandlers(viewer, spellCheck);
87	}
88
89	public void focusLost(FocusEvent e) {
90	deactivateHandlers();
91	if (selectionChangedListener != null) {
92	// make sure selection no text is selected when control looses focus
93	StyledText st = (StyledText) e.widget;
94	st.setSelectionRange(st.getCaretOffset(), 0);
95	// update action enablement
96	selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer, StructuredSelection.EMPTY));
97	}
98	}
99
100	}
101
102	private final Color colorIncoming;	58	private final Color colorIncoming;
103		59
104	public IHandlerActivation contentAssistHandlerActivation;
105
106	private final IHandlerService handlerService;
107
108	private Menu menu;	60	private Menu menu;
109		61
110	private IHandlerActivation quickAssistHandlerActivation;	62	private AbstractRenderingEngine renderingEngine;
111		63
112	private ISelectionChangedListener selectionChangedListener;	64	private final CommonTextSupport textSupport;
113		65
114	private AbstractRenderingEngine renderingEngine;	66	@Deprecated
		67	public IHandlerActivation contentAssistHandlerActivation;
115		68
116	AttributeEditorToolkit(IHandlerService handlerService) {	69	AttributeEditorToolkit(CommonTextSupport textSupport) {
117	this.handlerService = handlerService;	70	this.textSupport = textSupport;
118	IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();	71	IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();
119	colorIncoming = themeManager.getCurrentTheme().getColorRegistry().get(CommonThemes.COLOR_INCOMING_BACKGROUND);	72	colorIncoming = themeManager.getCurrentTheme().getColorRegistry().get(CommonThemes.COLOR_INCOMING_BACKGROUND);
120	}	73	}
121		74
122	private IHandlerActivation activateHandler(SourceViewer viewer, int operation, String actionDefinitionId) {
123	IHandler handler = createActionHandler(viewer, operation, actionDefinitionId);
124	return handlerService.activateHandler(actionDefinitionId, handler, //
125	new ActiveShellExpression(viewer.getTextWidget().getShell()));
126	}
127
128	private void activateHandlers(SourceViewer viewer, boolean spellCheck) {
129	deactivateHandlers();
130	if (spellCheck) {
131	quickAssistHandlerActivation = activateHandler(viewer, ISourceViewer.QUICK_ASSIST,
132	ITextEditorActionDefinitionIds.QUICK_ASSIST);
133	}
134	contentAssistHandlerActivation = activateHandler(viewer, ISourceViewer.CONTENTASSIST_PROPOSALS,
135	ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
136
137	}
138
139	public void adapt(AbstractAttributeEditor editor) {	75	public void adapt(AbstractAttributeEditor editor) {
140	if (editor.getControl() instanceof Text \|\| editor.getControl() instanceof CCombo) {	76	if (editor.getControl() instanceof Text \|\| editor.getControl() instanceof CCombo) {
141	Control control = editor.getControl();	77	Control control = editor.getControl();
Lines 154-190 Link Here
154	RichTextAttributeEditor richTextEditor = (RichTextAttributeEditor) editor;	90	RichTextAttributeEditor richTextEditor = (RichTextAttributeEditor) editor;
155	boolean spellCheck = hasSpellChecking(editor.getTaskAttribute());	91	boolean spellCheck = hasSpellChecking(editor.getTaskAttribute());
156	final SourceViewer viewer = richTextEditor.getViewer();	92	final SourceViewer viewer = richTextEditor.getViewer();
157	viewer.getControl().addFocusListener(new StyledTextFocusListener(viewer, spellCheck));	93	textSupport.install(viewer, spellCheck);
158	if (selectionChangedListener != null) {
159	viewer.addSelectionChangedListener(selectionChangedListener);
160	viewer.addTextListener(new ITextListener() {
161	public void textChanged(TextEvent event) {
162	if (selectionChangedListener != null) {
163	selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer,
164	viewer.getSelection()));
165	}
166	}
167	});
168	}
169	if (!editor.isReadOnly() && richTextEditor.getMode() == Mode.TASK_RELATION) {	94	if (!editor.isReadOnly() && richTextEditor.getMode() == Mode.TASK_RELATION) {
170	installContentAssistControlDecoration(viewer.getControl());	95	installContentAssistControlDecoration(viewer.getControl());
171	}	96	}
172	installMenu(viewer.getControl());	97	installMenu(viewer.getControl());
173	EditorUtil.setTextViewer(editor.getControl(), viewer);
174	} else {	98	} else {
175	final TextViewer viewer = EditorUtil.getTextViewer(editor.getControl());	99	final TextViewer viewer = EditorUtil.getTextViewer(editor.getControl());
176	if (viewer != null) {	100	if (viewer != null) {
177	if (selectionChangedListener != null) {	101	textSupport.install(viewer, false);
178	viewer.addSelectionChangedListener(selectionChangedListener);
179	viewer.addTextListener(new ITextListener() {
180	public void textChanged(TextEvent event) {
181	if (selectionChangedListener != null) {
182	selectionChangedListener.selectionChanged(new SelectionChangedEvent(viewer,
183	viewer.getSelection()));
184	}
185	}
186	});
187	}
188	installMenu(viewer.getControl());	102	installMenu(viewer.getControl());
189	}	103	}
190	}	104	}
Lines 236-254 Link Here
236	return controlDecoration;	150	return controlDecoration;
237	}	151	}
238		152
239	private IHandler createActionHandler(final SourceViewer viewer, final int operation, String actionDefinitionId) {
240	Action quickFixAction = new Action() {
241	@Override
242	public void run() {
243	if (viewer.canDoOperation(operation)) {
244	viewer.doOperation(operation);
245	}
246	}
247	};
248	quickFixAction.setActionDefinitionId(actionDefinitionId);
249	return new ActionHandler(quickFixAction);
250	}
251
252	/**	153	/**
253	* Creates an IContentProposalProvider to provide content assist proposals for the given attribute.	154	* Creates an IContentProposalProvider to provide content assist proposals for the given attribute.
254	*	155	*
Lines 264-282 Link Here
264	return new PersonProposalLabelProvider();	165	return new PersonProposalLabelProvider();
265	}	166	}
266		167
267	private void deactivateHandlers() {
268	if (quickAssistHandlerActivation != null) {
269	handlerService.deactivateHandler(quickAssistHandlerActivation);
270	quickAssistHandlerActivation = null;
271	}
272	if (contentAssistHandlerActivation != null) {
273	handlerService.deactivateHandler(contentAssistHandlerActivation);
274	contentAssistHandlerActivation = null;
275	}
276	}
277
278	void dispose() {	168	void dispose() {
279	deactivateHandlers();	169	// FIXME textSupport.deactivateHandlers();
280	}	170	}
281		171
282	public Color getColorIncoming() {	172	public Color getColorIncoming() {
Lines 298-307 Link Here
298	return renderingEngine;	188	return renderingEngine;
299	}	189	}
300		190
301	ISelectionChangedListener getSelectionChangedListener() {
302	return selectionChangedListener;
303	}
304
305	/**	191	/**
306	* Called to check if there's content assist available for the given attribute.	192	* Called to check if there's content assist available for the given attribute.
307	*	193	*
Lines 331-340 Link Here
331	this.menu = menu;	217	this.menu = menu;
332	}	218	}
333		219
334	void setSelectionChangedListener(ISelectionChangedListener selectionListener) {
335	this.selectionChangedListener = selectionListener;
336	}
337
338	public void setRenderingEngine(AbstractRenderingEngine renderingEngine) {	220	public void setRenderingEngine(AbstractRenderingEngine renderingEngine) {
339	this.renderingEngine = renderingEngine;	221	this.renderingEngine = renderingEngine;
340	}	222	}