Attachment #169620 for bug #278102

Lines 17-22 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
17	org.eclipse.ui.ide,	17	org.eclipse.ui.ide,
18	org.eclipse.ui.views,	18	org.eclipse.ui.views,
19	org.eclipse.ui.workbench.texteditor,	19	org.eclipse.ui.workbench.texteditor,
		20	org.eclipse.ui.navigator,
20	org.eclipse.mylyn.context.core;bundle-version="[3.0.0,4.0.0)",	21	org.eclipse.mylyn.context.core;bundle-version="[3.0.0,4.0.0)",
21	org.eclipse.mylyn.commons.core;bundle-version="[3.0.0,4.0.0)",	22	org.eclipse.mylyn.commons.core;bundle-version="[3.0.0,4.0.0)",
22	org.eclipse.mylyn.monitor.ui;bundle-version="[3.0.0,4.0.0)",	23	org.eclipse.mylyn.monitor.ui;bundle-version="[3.0.0,4.0.0)",

Lines 631-637 Link Here

(-)plugin.xml (-1 / +71 lines)
631	value="org.eclipse.mylyn.tasks.ui.views.tasks">	631	value="org.eclipse.mylyn.tasks.ui.views.tasks">
632	</parameter>	632	</parameter>
633	</key>	633	</key>
634	</extension>	634	<key
		635	sequence="M1+M2+M3+."
		636	commandId="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		637	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		638	</key>
		639	</extension>
635		640
636	<extension	641	<extension
637	point="org.eclipse.ui.themes">	642	point="org.eclipse.ui.themes">
Lines 828-833 Link Here
828	style="push"	833	style="push"
829	toolbarPath="org.eclipse.search.searchActionSet/Search"	834	toolbarPath="org.eclipse.search.searchActionSet/Search"
830	tooltip="%OpenTaskAction.tooltip"/>	835	tooltip="%OpenTaskAction.tooltip"/>
		836	<action
		837	definitionId="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		838	label="related Task Popup"
		839	class="org.eclipse.mylyn.internal.tasks.ui.actions.QuickOutlineTaskDataAction"
		840	menubarPath="navigate/showIn"
		841	id="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog">
		842	</action>
831	</actionSet>	843	</actionSet>
832	</extension>	844	</extension>
833		845
Lines 835-840 Link Here
835	<command id="org.eclipse.mylyn.tasks.ui.command.previousTask"	847	<command id="org.eclipse.mylyn.tasks.ui.command.previousTask"
836	defaultHandler="org.eclipse.mylyn.internal.tasks.ui.TaskHistoryHandler"	848	defaultHandler="org.eclipse.mylyn.internal.tasks.ui.TaskHistoryHandler"
837	name="%command.previousTask.name"/>	849	name="%command.previousTask.name"/>
		850	<command
		851	name="bbbb"
		852	description="aaaa"
		853	id="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		854	categoryId="org.eclipse.mylyn.tasks.ui.commands">
		855	</command>
838	</extension>	856	</extension>
839		857
840	<!-- command-based implementation of the previousTask/history dropdown,	858	<!-- command-based implementation of the previousTask/history dropdown,
Lines 1903-1906 Link Here
1903	</iterate>	1921	</iterate>
1904	</definition>	1922	</definition>
1905	</extension>	1923	</extension>
		1924
		1925	<!-- TaskData Quick Outline -->
		1926
		1927	<extension
		1928	point="org.eclipse.ui.navigator.viewer">
		1929	<viewer viewerId="org.eclipse.mylyn.internal.tasks.ui.taskdata.quick"/>
		1930	<viewerContentBinding viewerId="org.eclipse.mylyn.internal.tasks.ui.taskdata.quick">
		1931	<includes>
		1932	<contentExtension pattern="org.eclipse.mylyn.internal.tasks.ui.CommonViewerTaskDataContentProvider"/>
		1933	<contentExtension pattern="org.eclipse.ui.navigator.resources.filters.*"/>
		1934	</includes>
		1935	</viewerContentBinding>
		1936	<viewerActionBinding viewerId="org.eclipse.mylyn.internal.tasks.ui.taskdata.quick">
		1937	<includes>
		1938	<actionExtension pattern="org.eclipse.ui.navigator.resources.*"/>
		1939	</includes>
		1940	</viewerActionBinding>
		1941	</extension>
		1942	<extension
		1943	point="org.eclipse.ui.navigator.navigatorContent">
		1944	<navigatorContent
		1945	activeByDefault="true"
		1946	contentProvider="org.eclipse.mylyn.internal.tasks.ui.CommonViewerTaskDataContentProvider"
		1947	id="org.eclipse.mylyn.internal.tasks.ui.navigatorContent1"
		1948	labelProvider="org.eclipse.mylyn.internal.tasks.ui.CommonViewerTaskDataLabelProvider"
		1949	name="NR Content" >
		1950	<triggerPoints>
		1951	<or>
		1952	<instanceof value="org.eclipse.mylyn.tasks.core.data.TaskData"/>
		1953	</or>
		1954	</triggerPoints>
		1955	<possibleChildren>
		1956	<or>
		1957	<instanceof value="org.eclipse.mylyn.tasks.core.data.TaskAttribute"/>
		1958	<instanceof value="org.eclipse.mylyn.tasks.core.data.TaskData"/>
		1959	</or>
		1960	</possibleChildren>
		1961	</navigatorContent>
		1962	</extension>
		1963
		1964	<extension
		1965	point="org.eclipse.ui.navigator.viewer">
		1966	<viewerContentBinding viewerId="org.eclipse.mylyn.internal.tasks.ui.taskdata.quick">
		1967	<includes>
		1968	<contentExtension
		1969	isRoot="false"
		1970	pattern="org.eclipse.mylyn.internal.tasks.ui.navigatorContent1"/>
		1971	</includes>
		1972	</viewerContentBinding>
		1973	</extension>
		1974
		1975
1906	</plugin>	1976	</plugin>




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskData;

public class CommonViewerTaskDataContentProvider implements ITreeContentProvider {

	private boolean showTaskAttributes;

	public boolean isShowTaskAttributes() {
		return showTaskAttributes;
	}

	public void setShowTaskAttributes(boolean showTaskAttributes) {
		this.showTaskAttributes = showTaskAttributes;
	}

	public Object[] getChildren(Object parentElement) {
		Object[] result = {};
		if (parentElement instanceof TaskData) {
			TaskData node = (TaskData) parentElement;
			result = node.getRoot().getAttributes().values().toArray();
		} else if (parentElement instanceof TaskAttribute) {
			TaskAttribute node = (TaskAttribute) parentElement;
			result = node.getAttributes().values().toArray();
		} else if (parentElement instanceof TaskEditorOutlineNode) {
			result = ((TaskEditorOutlineNode) parentElement).getChildren();
		}
		return result;
	}

	public Object[] getElements(Object inputElement) {
		boolean b = TasksUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(ITasksUiPreferenceConstants.QUICKOUTLINE_TASKMODE_TASKDATA);

		if (inputElement instanceof TaskData) {
			if (b) {
				return getChildren(inputElement);
			} else {
				TaskEditorOutlineNode node = TaskEditorOutlineNode.parse((TaskData) inputElement);
				return node.getChildren();
			}
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
	 */
	public Object getParent(Object element) {
		if (element instanceof TaskData) {

			return null;
		} else if (element instanceof TaskAttribute) {
			TaskAttribute node = (TaskAttribute) element;
			return node.getParentAttribute();
		} else if (element instanceof TaskEditorOutlineNode) {
			return ((TaskEditorOutlineNode) element).getParent();
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
	 */
	public boolean hasChildren(Object element) {
		if (element instanceof TaskData) {
			TaskData node = (TaskData) element;
			return node.getRoot().getAttributes().size() > 0;
		} else if (element instanceof TaskAttribute) {
			TaskAttribute node = (TaskAttribute) element;
			return node.getAttributes().size() > 0;
		} else if (element instanceof TaskEditorOutlineNode) {
			return ((TaskEditorOutlineNode) element).getChildren().length > 0;
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
	 */
	public void dispose() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	}

}




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.ui.internal.misc.StringMatcher;

public class CommonViewerTaskDataFilter extends ViewerFilter {

	private StringMatcher stringMatcher;

	@Override
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (element instanceof TaskAttribute) {
			TaskAttribute attribute = (TaskAttribute) element;
			String metaType = attribute.getMetaData().getType();
			if (TaskAttribute.TYPE_OPERATION.equals(metaType)) {
				return false;
			}
		}
		if ((stringMatcher == null) || ((viewer instanceof TreeViewer) == false)) {
			return true;
		}
		TreeViewer treeViewer = (TreeViewer) viewer;
		// Match the pattern against the label of the given element
		String matchName = ((ILabelProvider) treeViewer.getLabelProvider()).getText(element);
		// Element passes the filter if it matches the pattern
		if ((matchName != null) && stringMatcher.match(matchName)) {
			return true;
		}
		return false;
	}

	public void setStringMatcher(StringMatcher stringMatcher) {
		this.stringMatcher = stringMatcher;
	}

}




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNodeLabelProvider;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMetaData;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.swt.graphics.Image;

public class CommonViewerTaskDataLabelProvider extends TaskEditorOutlineNodeLabelProvider {
	@Override
	public String getText(Object element) {
		String result = ""; //$NON-NLS-1$
		if (element instanceof TaskData) {
			TaskData node = (TaskData) element;
			result = node.getTaskId();
		} else if (element instanceof TaskAttribute) {
			TaskAttribute node = (TaskAttribute) element;
			TaskAttributeMetaData meta = node.getMetaData();
			if (meta != null) {
				String lable = meta.getLabel();
				if (lable != null) {
					result = lable + " (" + node.getId() + ")";
				} else {
					if (TaskAttribute.TYPE_ATTACHMENT.equals(meta.getType())) {
						result = "Attachment: " + node.getValue(); //$NON-NLS-1$
					} else if (TaskAttribute.TYPE_COMMENT.equals(meta.getType())) {
						result = "Comment: " + node.getValue(); //$NON-NLS-1$
					} else {
						result = "<" + node.getId() + ">"; //$NON-NLS-1$//$NON-NLS-2$
					}
				}
			}
		} else if (element instanceof TaskEditorOutlineNode) {
			result = super.getText(element);
		} else if (element instanceof String) {
			result = (String) element;
		}
		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
	 */
	@Override
	public Image getImage(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			return super.getImage(element);
		} else {
			return null;
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)
	 */
	@Override
	public void addListener(ILabelProviderListener listener) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()
	 */
	@Override
	public void dispose() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, java.lang.String)
	 */
	@Override
	public boolean isLabelProperty(Object element, String property) {
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)
	 */
	@Override
	public void removeListener(ILabelProviderListener listener) {
	}

}




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonFormUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskAttachment;
import org.eclipse.mylyn.internal.tasks.ui.editors.EditorUtil;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorAttributePart;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPart;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;

public class CommonViewerTaskDataOpenListener implements IOpenListener, IDoubleClickListener, MouseListener {

	private final Viewer viewer;

	public CommonViewerTaskDataOpenListener(Viewer viewer) {
		this.viewer = viewer;
	}

	public void mouseDoubleClick(MouseEvent e) {
		setSelection(e);
	}

	public void mouseDown(MouseEvent e) {
		setSelection(e);
	}

	public void mouseUp(MouseEvent e) {
		// ignore

	}

	public void doubleClick(DoubleClickEvent event) {
		open(null);
	}

	@SuppressWarnings("null")
	public void open(OpenEvent event) {
		StructuredSelection selection = (StructuredSelection) viewer.getSelection();
		Object object = selection.getFirstElement();
		IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		AbstractTaskEditorPage taskEditorPage = null;
		if (editorPart instanceof TaskEditor) {
			TaskEditor taskEditor = (TaskEditor) editorPart;
			IFormPage formPage = taskEditor.getActivePageInstance();
			if (formPage instanceof AbstractTaskEditorPage) {
				taskEditorPage = (AbstractTaskEditorPage) formPage;
			}
		}
		if (object instanceof TaskAttribute) {
			TaskAttribute attribute = (TaskAttribute) object;
			if (TaskAttribute.TYPE_ATTACHMENT.equals(attribute.getMetaData().getType())) {
				AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTACHMENTS);
				if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
					CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
					if (actionPart.getControl() instanceof Section) {
						Control client = actionPart.getControl();
						if (client instanceof Composite) {
							for (Control control : ((Composite) client).getChildren()) {
								if (control instanceof Composite) {
									for (Control control1 : ((Composite) control).getChildren()) {
										if (control1 instanceof org.eclipse.swt.widgets.Table) {
											org.eclipse.swt.widgets.Table attachmentTable = ((org.eclipse.swt.widgets.Table) control1);
											TableItem[] attachments = attachmentTable.getItems();
											int index = 0;
											for (TableItem attachment : attachments) {
												TaskAttachment attachmentData = ((TaskAttachment) attachment.getData());
												if (attachmentData.getTaskAttribute() == attribute) {
													attachmentTable.deselectAll();
													attachmentTable.select(index);
													IManagedForm mform = actionPart.getManagedForm();
													ScrolledForm form = mform.getForm();
//													EditorUtil.focusOn(form, attachmentTable, 30);
													taskEditorPage.focusOn(attachmentTable);
													break;
												}
												index++;
											}
										}
									}
								}
							}
						}
					}
				}
			} else {
				if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
					AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_COMMENTS);
					if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
						CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
						if (actionPart.getControl() instanceof Section) {
							Control client = ((Section) actionPart.getControl()).getClient();
							if (client instanceof Composite) {
								for (Control control : ((Composite) client).getChildren()) {
									// toggle subsections
									if (control instanceof Section) {
										CommonFormUtil.setExpanded((Section) control, true);
									}
								}
							}
						}
					}
				} else {
					TaskEditorAttributePart actionPart = (TaskEditorAttributePart) taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTRIBUTES);
					Section section = actionPart.getSection();
					boolean expanded = section.isExpanded();
					if (!expanded && actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
						CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
						if (!expanded) {
							CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), false);
						}
					}
				}
				taskEditorPage.reveal(attribute.getId());
			}
		} else if (object instanceof TaskEditorOutlineNode) {
			EditorUtil.focusFromStructuredSelection(object, taskEditorPage);
		}
	}

	private void setSelection(MouseEvent event) {
		try {
			Object selection = ((Tree) event.getSource()).getSelection()[0].getData();
			viewer.setSelection(new StructuredSelection(selection));
			open(null);
		} catch (Exception e) {
			// ignore
		}
	}

}

Lines 87-90 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/ITasksUiPreferenceConstants.java (+2 lines)
87	public static final String PREF_DATA_DIR = "org.eclipse.mylyn.data.dir"; //$NON-NLS-1$	87	public static final String PREF_DATA_DIR = "org.eclipse.mylyn.data.dir"; //$NON-NLS-1$
88		88
89	public static final String DEFAULT_ATTACHMENTS_DIRECTORY = "org.eclipse.mylyn.tasks.ui.attachments.defaultDirectory"; //$NON-NLS-1$	89	public static final String DEFAULT_ATTACHMENTS_DIRECTORY = "org.eclipse.mylyn.tasks.ui.attachments.defaultDirectory"; //$NON-NLS-1$
		90
		91	public static final String QUICKOUTLINE_TASKMODE_TASKDATA = "org.eclipse.mylyn.tasks.ui.quick.outline.taskmode.taskdata"; //$NON-NLS-1$
90	}	92	}




import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta.Type;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataStore;
import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;

import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.core.RepositoryTemplate;
import org.eclipse.mylyn.tasks.core.TaskActivationAdapter;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.AbstractTaskRepositoryLinkProvider;
import org.eclipse.mylyn.tasks.ui.TasksUi;

			return;
		}

		boolean enabled = TasksUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(ITasksUiPreferenceConstants.REPOSITORY_SYNCH_SCHEDULE_ENABLED);
		if (enabled) {
			long interval = TasksUiPlugin.getDefault()
					.getPreferenceStore()
					.getLong(ITasksUiPreferenceConstants.REPOSITORY_SYNCH_SCHEDULE_MILISECONDS);
			if (initial) {
				synchronizationScheduler.setInterval(DELAY_QUERY_REFRESH_ON_STARTUP, interval);
			} else {

			}
		}

		if (!MonitorUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED + ".checked")) { //$NON-NLS-1$
			if (!taskActivityMonitor.getActivationHistory().isEmpty()) {
				// tasks have been active before so fore preference enabled
				MonitorUiPlugin.getDefault()
						.getPreferenceStore()
						.setValue(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED, true);
			}
			MonitorUiPlugin.getDefault()
					.getPreferenceStore()
					.setValue(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED + ".checked", true); //$NON-NLS-1$
			MonitorUiPlugin.getDefault().savePluginPreferences();
		}



		store.setDefault(ITasksUiPreferenceConstants.AUTO_EXPAND_TASK_LIST, true);
		store.setDefault(ITasksUiPreferenceConstants.TASK_LIST_TOOL_TIPS_ENABLED, true);
		store.setDefault(ITasksUiPreferenceConstants.QUICKOUTLINE_TASKMODE_TASKDATA, false);
	}

	public static TaskActivityManager getTaskActivityManager() {

	}

	public boolean groupSubtasks(ITaskContainer element) {
		boolean groupSubtasks = TasksUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(ITasksUiPreferenceConstants.GROUP_SUBTASKS);

		if (element instanceof ITask) {
			AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(((ITask) element).getConnectorKind());




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.TaskTask;
import org.eclipse.mylyn.internal.tasks.ui.views.QuickOutlineTaskDataDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.PlatformUI;

public class QuickOutlineTaskDataAction implements IWorkbenchWindowActionDelegate {

	private QuickOutlineTaskDataDialog inplaceDialog;

	private TaskTask sel;

	public void run(IAction action) {
		Shell parent = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		inplaceDialog = new QuickOutlineTaskDataDialog(parent);
		inplaceDialog.open();
		inplaceDialog.setFocus();
	}

	public void selectionChanged(IAction action, ISelection selection) {
		// ignore
		if (selection instanceof StructuredSelection) {
			StructuredSelection a = (StructuredSelection) selection;
			if (a.size() > 0) {
				if (a.getFirstElement() instanceof TaskTask) {
					sel = (TaskTask) a.getFirstElement();
				}
			}
		}
	}

	public void dispose() {
		inplaceDialog = null;
	}

	public void init(IWorkbenchWindow window) {
		// ignore
	}

}




import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskAttachment;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.internal.tasks.ui.wizards.NewAttachmentWizardDialog;
import org.eclipse.mylyn.internal.tasks.ui.wizards.TaskAttachmentWizard.Mode;

import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPart;
import org.eclipse.mylyn.tasks.ui.editors.TaskFormPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;

import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Scrollable;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;

	 * @param control
	 *            The StyledText to scroll to
	 */
	public static void focusOn(ScrolledForm form, Control control) {
		int pos = 0;
		control.setEnabled(true);
		control.setFocus();

		} else {
			roundedBorder.setLayout(GridLayoutFactory.fillDefaults().margins(0, 6).create());
		}
		GridDataFactory.fillDefaults()
				.align(SWT.FILL, SWT.BEGINNING)
				.hint(EditorUtil.MAXIMUM_WIDTH, SWT.DEFAULT)
				.grab(true, false)
				.applyTo(roundedBorder);
		return roundedBorder;
	}


				textFont.dispose();
			}
		});
		Color color = PlatformUI.getWorkbench()
				.getThemeManager()
				.getCurrentTheme()
				.getColorRegistry()
				.get(CommonThemes.COLOR_COMPLETED);
		text.setForeground(color);
		return textFont;
	}

		}
	}

	public static void focusFromStructuredSelection(Object select, AbstractTaskEditorPage taskEditorPage) {
		if (select instanceof TaskEditorOutlineNode) {
			TaskEditorOutlineNode node = (TaskEditorOutlineNode) select;
			TaskAttribute attribute = node.getData();
			if (attribute != null) {
				if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
					AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_COMMENTS);
					if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
						CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
						if (actionPart.getControl() instanceof Section) {
							Control client = ((Section) actionPart.getControl()).getClient();
							if (client instanceof Composite) {
								for (Control control : ((Composite) client).getChildren()) {
									// toggle subsections
									if (control instanceof Section) {
										CommonFormUtil.setExpanded((Section) control, true);
									}
								}
							}
						}
					}
					taskEditorPage.reveal(attribute.getId());
				} else if (TaskAttribute.TYPE_ATTACHMENT.equals(attribute.getMetaData().getType())) {
					AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTACHMENTS);
					if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
						CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
						if (actionPart.getControl() instanceof Section) {
							Control client = actionPart.getControl();
							if (client instanceof Composite) {
								for (Control control : ((Composite) client).getChildren()) {
									if (control instanceof Composite) {
										for (Control control1 : ((Composite) control).getChildren()) {
											if (control1 instanceof org.eclipse.swt.widgets.Table) {
												org.eclipse.swt.widgets.Table attachmentTable = ((org.eclipse.swt.widgets.Table) control1);
												TableItem[] attachments = attachmentTable.getItems();
												int index = 0;
												for (TableItem attachment : attachments) {
													TaskAttachment attachmentData = ((TaskAttachment) attachment.getData());
													if (attachmentData.getTaskAttribute() == attribute) {
														attachmentTable.deselectAll();
														attachmentTable.select(index);
														IManagedForm mform = actionPart.getManagedForm();
														ScrolledForm form = mform.getForm();
														EditorUtil.focusOn(form, attachmentTable);
														break;
													}
													index++;
												}
											}
										}
									}
								}
							}
						}
					}
				}
			} else {
				taskEditorPage.reveal(node.getLabel());
			}
		}
	}
}

Lines 151-156 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/Messages.java (+2 lines)
151		151
152	public static String TaskEditorNewCommentPart_New_Comment;	152	public static String TaskEditorNewCommentPart_New_Comment;
153		153
		154	public static String TaskEditorOutlineNode_Attachments;
		155
154	public static String TaskEditorOutlineNode_Comments;	156	public static String TaskEditorOutlineNode_Comments;
155		157
156	public static String TaskEditorOutlineNode_Description;	158	public static String TaskEditorOutlineNode_Description;

Lines 17-23 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorOutlineNode.java (+43 lines)
17		17
18	import org.eclipse.core.runtime.Assert;	18	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;	19	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
		20	import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;
20	import org.eclipse.mylyn.tasks.core.IRepositoryPerson;	21	import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
		22	import org.eclipse.mylyn.tasks.core.ITaskAttachment;
21	import org.eclipse.mylyn.tasks.core.ITaskComment;	23	import org.eclipse.mylyn.tasks.core.ITaskComment;
22	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;	24	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
23	import org.eclipse.mylyn.tasks.core.data.TaskData;	25	import org.eclipse.mylyn.tasks.core.data.TaskData;
Lines 35-40 Link Here
35		37
36	public static final String LABEL_NEW_COMMENT = Messages.TaskEditorOutlineNode_New_Comment;	38	public static final String LABEL_NEW_COMMENT = Messages.TaskEditorOutlineNode_New_Comment;
37		39
		40	public static final String LABEL_ATTACHMENTS = Messages.TaskEditorOutlineNode_Attachments;
		41
38	private static TaskEditorOutlineNode createNode(TaskData taskData, String attributeId, String label) {	42	private static TaskEditorOutlineNode createNode(TaskData taskData, String attributeId, String label) {
39	TaskAttribute taskAttribute = taskData.getRoot().getMappedAttribute(attributeId);	43	TaskAttribute taskAttribute = taskData.getRoot().getMappedAttribute(attributeId);
40	if (taskAttribute != null) {	44	if (taskAttribute != null) {
Lines 69-74 Link Here
69	node.setTaskComment(taskComment);	73	node.setTaskComment(taskComment);
70	return node;	74	return node;
71	}	75	}
		76	} else if (TaskAttribute.TYPE_ATTACHMENT.equals(type)) {
		77	ITaskAttachment taskAttachment = TasksUiPlugin.getRepositoryModel().createTaskAttachment(taskAttribute);
		78	if (taskAttachment != null) {
		79	taskAttribute.getTaskData().getAttributeMapper().updateTaskAttachment(taskAttachment, taskAttribute);
		80	StringBuilder sb = new StringBuilder();
		81	sb.append(taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute));
		82	sb.append(": "); //$NON-NLS-1$
		83	if (AttachmentUtil.isContext(taskAttachment)) {
		84	sb.append(Messages.AttachmentTableLabelProvider_Task_Context);
		85	} else if (taskAttachment.isPatch()) {
		86	sb.append(Messages.AttachmentTableLabelProvider_Patch);
		87	} else {
		88	sb.append(taskAttachment.getFileName());
		89	}
		90	TaskEditorOutlineNode node = new TaskEditorOutlineNode(sb.toString(), taskAttribute);
		91	node.setTaskAttachment(taskAttachment);
		92	return node;
		93	}
72	} else {	94	} else {
73	String label = taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute);	95	String label = taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute);
74	return new TaskEditorOutlineNode(label, taskAttribute);	96	return new TaskEditorOutlineNode(label, taskAttribute);
Lines 82-87 Link Here
82	rootNode = new TaskEditorOutlineNode(Messages.TaskEditorOutlineNode_Task_ + taskData.getTaskId());	104	rootNode = new TaskEditorOutlineNode(Messages.TaskEditorOutlineNode_Task_ + taskData.getTaskId());
83	}	105	}
84	addNode(rootNode, taskData, TaskAttribute.DESCRIPTION, LABEL_DESCRIPTION);	106	addNode(rootNode, taskData, TaskAttribute.DESCRIPTION, LABEL_DESCRIPTION);
		107	List<TaskAttribute> attachments = taskData.getAttributeMapper().getAttributesByType(taskData,
		108	TaskAttribute.TYPE_ATTACHMENT);
		109	if (attachments.size() > 0) {
		110	TaskEditorOutlineNode attachmentNode = new TaskEditorOutlineNode(LABEL_ATTACHMENTS);
		111	rootNode.addChild(attachmentNode);
		112	for (TaskAttribute attachmentAttribute : attachments) {
		113	TaskEditorOutlineNode node = createNode(attachmentAttribute);
		114	if (node != null) {
		115	attachmentNode.addChild(node);
		116	}
		117	}
		118	}
85	List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData,	119	List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData,
86	TaskAttribute.TYPE_COMMENT);	120	TaskAttribute.TYPE_COMMENT);
87	if (comments.size() > 0) {	121	if (comments.size() > 0) {
Lines 118-123 Link Here
118		152
119	private ITaskComment taskComment;	153	private ITaskComment taskComment;
120		154
		155	private ITaskAttachment taskAttachment;
		156
121	public TaskEditorOutlineNode(String label) {	157	public TaskEditorOutlineNode(String label) {
122	this(label, null);	158	this(label, null);
123	}	159	}
Lines 183-186 Link Here
183	return getLabel();	219	return getLabel();
184	}	220	}
185		221
		222	public ITaskAttachment getTaskAttachment() {
		223	return taskAttachment;
		224	}
		225
		226	public void setTaskAttachment(ITaskAttachment taskAttachment) {
		227	this.taskAttachment = taskAttachment;
		228	}
186	}	229	}




/*******************************************************************************
 * Copyright (c) 2010 Frank Beckers 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;
import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
import org.eclipse.mylyn.tasks.core.ITaskAttachment;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.internal.WorkbenchImages;

public class TaskEditorOutlineNodeLabelProvider extends LabelProvider {
	private static final String[] IMAGE_EXTENSIONS = { "jpg", "gif", "png", "tiff", "tif", "bmp" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$	@Override

	@Override
	public Image getImage(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
			if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
					|| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())) {
				return CommonImages.getImage(TasksUiImages.COMMENT);
			}
			if (TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
				return CommonImages.getImage(TasksUiImages.TASK_NOTES);
			} else if (node.getTaskComment() != null) {
				IRepositoryPerson author = node.getTaskComment().getAuthor();
				TaskAttribute taskAttribute = node.getData();
				String repositoryUrl = taskAttribute.getTaskData().getRepositoryUrl();
				String connectorKind = null;
				TaskRepository taskRepository = null;
				if (repositoryUrl != null) {
					connectorKind = taskAttribute.getTaskData().getConnectorKind();
					if (connectorKind != null) {
						taskRepository = TasksUi.getRepositoryManager().getRepository(connectorKind, repositoryUrl);
					}
				}
				if (taskRepository != null && author != null
						&& author.getPersonId().equals(taskRepository.getUserName())) {
					return CommonImages.getImage(CommonImages.PERSON_ME);
				} else {
					return CommonImages.getImage(CommonImages.PERSON);
				}
			} else if (node.getTaskAttachment() != null) {
				ITaskAttachment attachment = node.getTaskAttachment();
				if (AttachmentUtil.isContext(attachment)) {
					return CommonImages.getImage(TasksUiImages.CONTEXT_TRANSFER);
				} else if (attachment.isPatch()) {
					return CommonImages.getImage(TasksUiImages.TASK_ATTACHMENT_PATCH);
				} else {
					String filename = attachment.getFileName();
					if (filename != null) {
						int dotIndex = filename.lastIndexOf('.');
						if (dotIndex != -1) {
							String fileType = filename.substring(dotIndex + 1);
							for (String element2 : IMAGE_EXTENSIONS) {
								if (element2.equalsIgnoreCase(fileType)) {
									return CommonImages.getImage(CommonImages.IMAGE_FILE);
								}
							}
						}
					}
					return WorkbenchImages.getImage(ISharedImages.IMG_OBJ_FILE);
				}
			} else {
				return CommonImages.getImage(TasksUiImages.TASK);
			}
		} else {
			return super.getImage(element);
		}
	}

	@Override
	public String getText(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
			return node.getLabel();
		}
		return super.getText(element);
	}

}




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

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;


		super.createControl(parent);
		viewer = getTreeViewer();
		viewer.setContentProvider(new TaskEditorOutlineContentProvider());
		viewer.setLabelProvider(new TaskEditorOutlineNodeLabelProvider());
			@Override
			public Image getImage(Object element) {
				if (element instanceof TaskEditorOutlineNode) {
					TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
					if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
							|| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())) {
						return CommonImages.getImage(TasksUiImages.COMMENT);
					}
					if (TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
						return CommonImages.getImage(TasksUiImages.TASK_NOTES);
					} else if (node.getTaskComment() != null) {
						IRepositoryPerson author = node.getTaskComment().getAuthor();
						if (taskRepository != null && author != null
								&& author.getPersonId().equals(taskRepository.getUserName())) {
							return CommonImages.getImage(CommonImages.PERSON_ME);
						} else {
							return CommonImages.getImage(CommonImages.PERSON);
						}
					} else {
						return CommonImages.getImage(TasksUiImages.TASK);
					}
				} else {
					return super.getImage(element);
				}
			}

			@Override
			public String getText(Object element) {
				if (element instanceof TaskEditorOutlineNode) {
					TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
					return node.getLabel();
				}
				return super.getText(element);
			}
		});
		viewer.setInput(model);
		viewer.expandAll();
	}

Lines 83-88 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/messages.properties (+1 lines)
83	TaskEditorDescriptionPart_Search=Search	83	TaskEditorDescriptionPart_Search=Search
84		84
85	TaskEditorNewCommentPart_New_Comment=New Comment	85	TaskEditorNewCommentPart_New_Comment=New Comment
		86	TaskEditorOutlineNode_Attachments=Attachments
86	TaskEditorOutlineNode_Comments=Comments	87	TaskEditorOutlineNode_Comments=Comments
87	TaskEditorOutlineNode_Description=Description	88	TaskEditorOutlineNode_Description=Description
88	TaskEditorOutlineNode_New_Comment=New Comment	89	TaskEditorOutlineNode_New_Comment=New Comment

Lines 29-34 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/Messages.java (+4 lines)
29		29
30	public static String PriorityDropDownAction_Filter_Priority_Lower_Than;	30	public static String PriorityDropDownAction_Filter_Priority_Lower_Than;
31		31
		32	public static String QuickOutlineTaskDataDialog_InfoText;
		33
		34	public static String QuickOutlineTaskDataDialog_ShowRawData;
		35
32	public static String RepositoryElementActionGroup_Copy_Detail_Menu_Label;	36	public static String RepositoryElementActionGroup_Copy_Detail_Menu_Label;
33		37
34	public static String RepositoryElementActionGroup_New;	38	public static String RepositoryElementActionGroup_New;




/*******************************************************************************
 * Copyright (c) 2010 Frank Becker 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:
 *     Frank Becker - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.PopupDialog;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlExtension;
import org.eclipse.jface.text.IInformationControlExtension2;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.ui.CommonViewerTaskDataFilter;
import org.eclipse.mylyn.internal.tasks.ui.CommonViewerTaskDataOpenListener;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.data.TaskData;
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.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.internal.misc.StringMatcher;
import org.eclipse.ui.navigator.CommonViewer;

public class QuickOutlineTaskDataDialog extends PopupDialog implements IInformationControl,
		IInformationControlExtension, IInformationControlExtension2, DisposeListener {

	public static final String ID_VIEWER = "org.eclipse.mylyn.internal.tasks.ui.taskdata.quick"; //$NON-NLS-1$

	private CommonViewer commonViewer;

	private Text fFilterText;

	private StringMatcher fStringMatcher;

	private CommonViewerTaskDataFilter namePatternFilter;

	private CommonViewerTaskDataOpenListener openListener;

	public QuickOutlineTaskDataDialog(Shell parent) {
		super(parent, SWT.RESIZE, true, true, true, true, true, null, Messages.QuickOutlineTaskDataDialog_InfoText);
		create();
	}

	@Override
	public boolean close() {
		// nothing additional to dispose
		return super.close();
	}

	@Override
	protected Control createDialogArea(Composite parent) {
		createViewer(parent);
		createUIListenersTreeViewer();
		addDisposeListener(this);

		return commonViewer.getControl();
	}

	private void createViewer(Composite parent) {
		Control composite = super.createDialogArea(parent);
		commonViewer = createCommonViewer((Composite) composite);
		openListener = new CommonViewerTaskDataOpenListener(commonViewer);

		commonViewer.addOpenListener(openListener);
		commonViewer.getTree().addMouseListener(openListener);

		namePatternFilter = new CommonViewerTaskDataFilter();
		commonViewer.addFilter(namePatternFilter);
		try {
			commonViewer.getControl().setRedraw(false);
			IEditorPart activeEditor = PlatformUI.getWorkbench()
					.getActiveWorkbenchWindow()
					.getActivePage()
					.getActiveEditor();
			if (activeEditor instanceof TaskEditor) {
				TaskEditor taskEditor = (TaskEditor) activeEditor;
				IFormPage pageInstance = taskEditor.getActivePageInstance();
				if (pageInstance instanceof AbstractTaskEditorPage) {
					AbstractTaskEditorPage taskEditorPage = (AbstractTaskEditorPage) pageInstance;
					TaskData taskData = taskEditorPage.getModel().getTaskData();
					commonViewer.setInput(taskData);
				}
			}
			commonViewer.expandAll();
		} finally {
			commonViewer.getControl().setRedraw(true);
		}
	}

	protected CommonViewer createCommonViewer(Composite parent) {
		CommonViewer viewer = new CommonViewer(ID_VIEWER, parent, SWT.H_SCROLL | SWT.V_SCROLL);
		viewer.setUseHashlookup(true);
		viewer.getControl().setLayoutData(new GridData(500, 400));
		return viewer;
	}

	@Override
	protected void fillDialogMenu(IMenuManager dialogMenu) {
		dialogMenu.add(new Separator());
		super.fillDialogMenu(dialogMenu);
	}

	private void createUIListenersTreeViewer() {
		final Tree tree = commonViewer.getTree();
		tree.addKeyListener(new KeyListener() {
			public void keyPressed(KeyEvent e) {
				if (e.character == 0x1B) {
					// Dispose on ESC key press
					dispose();
				}
			}

			public void keyReleased(KeyEvent e) {
				// ignore
			}
		});

		tree.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseUp(MouseEvent e) {
				handleTreeViewerMouseUp(tree, e);
			}
		});

		tree.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				// ignore
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				gotoSelectedElement();
			}
		});
	}

	private void handleTreeViewerMouseUp(final Tree tree, MouseEvent e) {
		if ((tree.getSelectionCount() < 1) || (e.button != 1) || (tree.equals(e.getSource()) == false)) {
			return;
		}
		// Selection is made in the selection changed listener
		Object object = tree.getItem(new Point(e.x, e.y));
		TreeItem selection = tree.getSelection()[0];
		if (selection.equals(object)) {
			gotoSelectedElement();
		}
	}

	private Object getSelectedElement() {
		if (commonViewer == null) {
			return null;
		}
		return ((IStructuredSelection) commonViewer.getSelection()).getFirstElement();
	}

	public void addDisposeListener(DisposeListener listener) {
		getShell().addDisposeListener(listener);
	}

	public void addFocusListener(FocusListener listener) {
		getShell().addFocusListener(listener);
	}

	public Point computeSizeHint() {
		// Note that it already has the persisted size if persisting is enabled.
		return getShell().getSize();
	}

	public void dispose() {
		close();
	}

	public boolean isFocusControl() {
		if (commonViewer.getControl().isFocusControl() || fFilterText.isFocusControl()) {
			return true;
		}
		return false;
	}

	public void removeDisposeListener(DisposeListener listener) {
		getShell().removeDisposeListener(listener);
	}

	public void removeFocusListener(FocusListener listener) {
		getShell().removeFocusListener(listener);
	}

	public void setBackgroundColor(Color background) {
		applyBackgroundColor(background, getContents());
	}

	public void setFocus() {
		getShell().forceFocus();
		fFilterText.setFocus();
	}

	public void setForegroundColor(Color foreground) {
		applyForegroundColor(foreground, getContents());
	}

	public void setInformation(String information) {
		// See IInformationControlExtension2
	}

	public void setLocation(Point location) {
		/*
		 * If the location is persisted, it gets managed by PopupDialog - fine. Otherwise, the location is
		 * computed in Window#getInitialLocation, which will center it in the parent shell / main
		 * monitor, which is wrong for two reasons:
		 * - we want to center over the editor / subject control, not the parent shell
		 * - the center is computed via the initalSize, which may be also wrong since the size may 
		 *   have been updated since via min/max sizing of AbstractInformationControlManager.
		 * In that case, override the location with the one computed by the manager. Note that
		 * the call to constrainShellSize in PopupDialog.open will still ensure that the shell is
		 * entirely visible.
		 */
		if (getPersistLocation() == false || getDialogSettings() == null) {
			getShell().setLocation(location);
		}
	}

	public void setSize(int width, int height) {
		getShell().setSize(width, height);
	}

	public void setSizeConstraints(int maxWidth, int maxHeight) {
		// Ignore
	}

	public void setVisible(boolean visible) {
		if (visible) {
			open();
		} else {
			saveDialogBounds(getShell());
			getShell().setVisible(false);
		}
	}

	public boolean hasContents() {
		if ((commonViewer == null) || (commonViewer.getInput() == null)) {
			return false;
		}
		return true;
	}

	public void setInput(Object input) {
		// Input comes from PDESourceInfoProvider.getInformation2()
		// The input should be a model object of some sort
		// Turn it into a structured selection and set the selection in the tree
		if (input != null) {
			commonViewer.setSelection(new StructuredSelection(input));
		}
	}

	public void widgetDisposed(DisposeEvent e) {
		// Note: We do not reuse the dialog
		commonViewer = null;
		fFilterText = null;
	}

	@Override
	protected Control createTitleControl(Composite parent) {
		Composite control = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, false);
		layout.marginHeight = 0;
		control.setLayout(layout);
		control.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		// Applies only to dialog title - not body.  See createDialogArea
		// Create the text widget
		createUIWidgetFilterText(control);
		// Add listeners to the text widget
		createUIListenersFilterText();
		final Button showTaskDataButton = new Button(control, SWT.CHECK);
		showTaskDataButton.setText(Messages.QuickOutlineTaskDataDialog_ShowRawData);
		showTaskDataButton.setSelection(TasksUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(ITasksUiPreferenceConstants.QUICKOUTLINE_TASKMODE_TASKDATA));
		showTaskDataButton.addSelectionListener(new SelectionListener() {

			public void widgetSelected(SelectionEvent e) {
				// ignore
				boolean selection = showTaskDataButton.getSelection();
				TasksUiPlugin.getDefault()
						.getPreferenceStore()
						.setValue(ITasksUiPreferenceConstants.QUICKOUTLINE_TASKMODE_TASKDATA, selection);
				IEditorPart activeEditor = PlatformUI.getWorkbench()
						.getActiveWorkbenchWindow()
						.getActivePage()
						.getActiveEditor();
				if (activeEditor instanceof TaskEditor) {
					TaskEditor taskEditor = (TaskEditor) activeEditor;
					IFormPage pageInstance = taskEditor.getActivePageInstance();
					if (pageInstance instanceof AbstractTaskEditorPage) {
						AbstractTaskEditorPage taskEditorPage = (AbstractTaskEditorPage) pageInstance;
						TaskData taskData = taskEditorPage.getModel().getTaskData();
						commonViewer.setInput(taskData);
						if (!selection) {
							commonViewer.expandAll();
						}
					}
				}

			}

			public void widgetDefaultSelected(SelectionEvent e) {
				// ignore

			}
		});

		// Return the text widget
		return control;
	}

	private void createUIWidgetFilterText(Composite parent) {
		// Create the widget
		fFilterText = new Text(parent, SWT.NONE);
		// Set the font 
		GC gc = new GC(parent);
		gc.setFont(parent.getFont());
		FontMetrics fontMetrics = gc.getFontMetrics();
		gc.dispose();
		// Create the layout
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.heightHint = Dialog.convertHeightInCharsToPixels(fontMetrics, 1);
		data.horizontalAlignment = GridData.FILL;
		data.verticalAlignment = GridData.CENTER;
		fFilterText.setLayoutData(data);
	}

	/**
	 * 
	 */
	private void gotoSelectedElement() {
		Object selectedElement = getSelectedElement();
		if (selectedElement == null) {
			return;
		}
		dispose();
	}

	private void createUIListenersFilterText() {
		fFilterText.addKeyListener(new KeyListener() {
			public void keyPressed(KeyEvent e) {
				if (e.keyCode == 0x0D) {
					// Return key was pressed
					gotoSelectedElement();
				} else if (e.keyCode == SWT.ARROW_DOWN) {
					// Down key was pressed
					commonViewer.getTree().setFocus();
				} else if (e.keyCode == SWT.ARROW_UP) {
					// Up key was pressed
					commonViewer.getTree().setFocus();
				} else if (e.character == 0x1B) {
					// Escape key was pressed
					dispose();
				}
			}

			public void keyReleased(KeyEvent e) {
				// NO-OP
			}
		});
		// Handle text modify events
		fFilterText.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				String text = ((Text) e.widget).getText();
				int length = text.length();
				if (length > 0) {
					// Append a '*' pattern to the end of the text value if it
					// does not have one already
					if (text.charAt(length - 1) != '*') {
						text = text + '*';
					}
					// Prepend a '*' pattern to the beginning of the text value
					// if it does not have one already
					if (text.charAt(0) != '*') {
						text = '*' + text;
					}
				}
				// Set and update the pattern
				setMatcherString(text, true);
			}
		});
	}

	/**
	 * Sets the patterns to filter out for the receiver.
	 * <p>
	 * The following characters have special meaning: ? => any character * => any string
	 * </p>
	 * 
	 * @param pattern
	 *            the pattern
	 * @param update
	 *            <code>true</code> if the viewer should be updated
	 */
	private void setMatcherString(String pattern, boolean update) {
		if (pattern.length() == 0) {
			fStringMatcher = null;
		} else {
			fStringMatcher = new StringMatcher(pattern, true, false);
		}
		// Update the name pattern filter on the tree viewer
		namePatternFilter.setStringMatcher(fStringMatcher);
		// Update the tree viewer according to the pattern
		if (update) {
			stringMatcherUpdated();
		}
	}

	/**
	 * The string matcher has been modified. The default implementation refreshes the view and selects the first matched
	 * element
	 */
	private void stringMatcherUpdated() {
		// Refresh the tree viewer to re-filter
		commonViewer.getControl().setRedraw(false);
		commonViewer.refresh();
		commonViewer.expandAll();
		selectFirstMatch();
		commonViewer.getControl().setRedraw(true);
	}

	/**
	 * Selects the first element in the tree which matches the current filter pattern.
	 */
	private void selectFirstMatch() {
		Tree tree = commonViewer.getTree();
		Object element = findFirstMatchToPattern(tree.getItems());
		if (element != null) {
			commonViewer.setSelection(new StructuredSelection(element), true);
		} else {
			commonViewer.setSelection(StructuredSelection.EMPTY);
		}
	}

	/**
	 * @param items
	 * @return
	 */
	private Object findFirstMatchToPattern(TreeItem[] items) {
		// Match the string pattern against labels
		ILabelProvider labelProvider = (ILabelProvider) commonViewer.getLabelProvider();
		// Process each item in the tree
		for (TreeItem item : items) {
			Object element = item.getData();
			// Return the first element if no pattern is set
			if (fStringMatcher == null) {
				return element;
			}
			// Return the element if it matches the pattern
			if (element != null) {
				String label = labelProvider.getText(element);
				if (fStringMatcher.match(label)) {
					return element;
				}
			}
			// Recursively check the elements children for a match
			element = findFirstMatchToPattern(item.getItems());
			// Return the child element match if found
			if (element != null) {
				return element;
			}
		}
		// No match found
		return null;
	}

}

Lines 11-16 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/messages.properties (+2 lines)
11	DisconnectRepositoryAction_Disconnected=Disconnected	11	DisconnectRepositoryAction_Disconnected=Disconnected
12		12
13	PriorityDropDownAction_Filter_Priority_Lower_Than=Hide Priority Lower Than	13	PriorityDropDownAction_Filter_Priority_Lower_Than=Hide Priority Lower Than
		14	QuickOutlineTaskDataDialog_InfoText=TaskDetail
		15	QuickOutlineTaskDataDialog_ShowRawData=show raw Data
14	RepositoryElementActionGroup_Copy_Detail_Menu_Label=Copy Details	16	RepositoryElementActionGroup_Copy_Detail_Menu_Label=Copy Details
15	RepositoryElementActionGroup_New=New	17	RepositoryElementActionGroup_New=New
16		18




import org.eclipse.mylyn.tasks.core.RepositoryStatus;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.ITaskDataWorkingCopy;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskDataModel;
import org.eclipse.mylyn.tasks.core.data.TaskDataModelEvent;

import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.services.IDisposable;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

					ISelection selection = event.getSelection();
					if (selection instanceof StructuredSelection) {
						Object select = ((StructuredSelection) selection).getFirstElement();
						EditorUtil.focusFromStructuredSelection(select, AbstractTaskEditorPage.this);
						getEditor().setActivePage(getId());
							TaskAttribute attribute = node.getData();
							if (attribute != null) {
								if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
									AbstractTaskEditorPart actionPart = getPart(ID_PART_COMMENTS);
									if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
										CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
										if (actionPart.getControl() instanceof Section) {
											Control client = ((Section) actionPart.getControl()).getClient();
											if (client instanceof Composite) {
												for (Control control : ((Composite) client).getChildren()) {
													// toggle subsections
													if (control instanceof Section) {
														CommonFormUtil.setExpanded((Section) control, true);
													}
												}
											}
										}
									}
								}
								EditorUtil.reveal(form, attribute.getId());
							} else {
								EditorUtil.reveal(form, node.getLabel());
							}
							getEditor().setActivePage(getId());
						}
					}
				}
			});

			if (part.getControl() != null) {
				if (ID_PART_ACTIONS.equals(part.getPartId())) {
					// do not expand horizontally
					GridDataFactory.fillDefaults()
							.align(SWT.FILL, SWT.FILL)
							.grab(false, false)
							.applyTo(part.getControl());
				} else {
					if (part.getExpandVertically()) {
						GridDataFactory.fillDefaults()
								.align(SWT.FILL, SWT.FILL)
								.grab(true, true)
								.applyTo(part.getControl());
					} else {
						GridDataFactory.fillDefaults()
								.align(SWT.FILL, SWT.TOP)
								.grab(true, false)
								.applyTo(part.getControl());
					}
				}
				// for outline

//		}
//	}

	/**
	 * @since 3.4
	 */
	public boolean reveal(String key) {
		return EditorUtil.reveal(form, key);
	}

	/**
	 * @since 3.4
	 */
	public void focusOn(Control control) {
		EditorUtil.focusOn(form, control);
	}
}

Return to bug 278102

Lines 92-98 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage.java (-35 / +27 lines)
92	import org.eclipse.mylyn.tasks.core.RepositoryStatus;	92	import org.eclipse.mylyn.tasks.core.RepositoryStatus;
93	import org.eclipse.mylyn.tasks.core.TaskRepository;	93	import org.eclipse.mylyn.tasks.core.TaskRepository;
94	import org.eclipse.mylyn.tasks.core.data.ITaskDataWorkingCopy;	94	import org.eclipse.mylyn.tasks.core.data.ITaskDataWorkingCopy;
95	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
96	import org.eclipse.mylyn.tasks.core.data.TaskData;	95	import org.eclipse.mylyn.tasks.core.data.TaskData;
97	import org.eclipse.mylyn.tasks.core.data.TaskDataModel;	96	import org.eclipse.mylyn.tasks.core.data.TaskDataModel;
98	import org.eclipse.mylyn.tasks.core.data.TaskDataModelEvent;	97	import org.eclipse.mylyn.tasks.core.data.TaskDataModelEvent;
Lines 136-142 Link Here
136	import org.eclipse.ui.forms.widgets.ExpandableComposite;	135	import org.eclipse.ui.forms.widgets.ExpandableComposite;
137	import org.eclipse.ui.forms.widgets.FormToolkit;	136	import org.eclipse.ui.forms.widgets.FormToolkit;
138	import org.eclipse.ui.forms.widgets.ScrolledForm;	137	import org.eclipse.ui.forms.widgets.ScrolledForm;
139	import org.eclipse.ui.forms.widgets.Section;
140	import org.eclipse.ui.handlers.IHandlerService;	138	import org.eclipse.ui.handlers.IHandlerService;
141	import org.eclipse.ui.services.IDisposable;	139	import org.eclipse.ui.services.IDisposable;
142	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;	140	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
Lines 1033-1065 Link Here
1033	ISelection selection = event.getSelection();	1031	ISelection selection = event.getSelection();
1034	if (selection instanceof StructuredSelection) {	1032	if (selection instanceof StructuredSelection) {
1035	Object select = ((StructuredSelection) selection).getFirstElement();	1033	Object select = ((StructuredSelection) selection).getFirstElement();
1036	if (select instanceof TaskEditorOutlineNode) {	1034	EditorUtil.focusFromStructuredSelection(select, AbstractTaskEditorPage.this);
1037	TaskEditorOutlineNode node = (TaskEditorOutlineNode) select;	1035	getEditor().setActivePage(getId());
1038	TaskAttribute attribute = node.getData();
1039	if (attribute != null) {
1040	if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
1041	AbstractTaskEditorPart actionPart = getPart(ID_PART_COMMENTS);
1042	if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
1043	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
1044	if (actionPart.getControl() instanceof Section) {
1045	Control client = ((Section) actionPart.getControl()).getClient();
1046	if (client instanceof Composite) {
1047	for (Control control : ((Composite) client).getChildren()) {
1048	// toggle subsections
1049	if (control instanceof Section) {
1050	CommonFormUtil.setExpanded((Section) control, true);
1051	}
1052	}
1053	}
1054	}
1055	}
1056	}
1057	EditorUtil.reveal(form, attribute.getId());
1058	} else {
1059	EditorUtil.reveal(form, node.getLabel());
1060	}
1061	getEditor().setActivePage(getId());
1062	}
1063	}	1036	}
1064	}	1037	}
1065	});	1038	});
Lines 1239-1253 Link Here
1239	if (part.getControl() != null) {	1212	if (part.getControl() != null) {
1240	if (ID_PART_ACTIONS.equals(part.getPartId())) {	1213	if (ID_PART_ACTIONS.equals(part.getPartId())) {
1241	// do not expand horizontally	1214	// do not expand horizontally
1242	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(false, false).applyTo(	1215	GridDataFactory.fillDefaults()
1243	part.getControl());	1216	.align(SWT.FILL, SWT.FILL)
		1217	.grab(false, false)
		1218	.applyTo(part.getControl());
1244	} else {	1219	} else {
1245	if (part.getExpandVertically()) {	1220	if (part.getExpandVertically()) {
1246	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(	1221	GridDataFactory.fillDefaults()
1247	part.getControl());	1222	.align(SWT.FILL, SWT.FILL)
		1223	.grab(true, true)
		1224	.applyTo(part.getControl());
1248	} else {	1225	} else {
1249	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.TOP).grab(true, false).applyTo(	1226	GridDataFactory.fillDefaults()
1250	part.getControl());	1227	.align(SWT.FILL, SWT.TOP)
		1228	.grab(true, false)
		1229	.applyTo(part.getControl());
1251	}	1230	}
1252	}	1231	}
1253	// for outline	1232	// for outline
Lines 1670-1673 Link Here
1670	// }	1649	// }
1671	// }	1650	// }
1672		1651
		1652	/**
		1653	* @since 3.4
		1654	*/
		1655	public boolean reveal(String key) {
		1656	return EditorUtil.reveal(form, key);
		1657	}
		1658
		1659	/**
		1660	* @since 3.4
		1661	*/
		1662	public void focusOn(Control control) {
		1663	EditorUtil.focusOn(form, control);
		1664	}
1673	}	1665	}

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/CommonViewerTaskDataContentProvider.java (+106 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 Frank Becker 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	* Frank Becker - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.tasks.ui;
13
14	import org.eclipse.jface.viewers.ITreeContentProvider;
15	import org.eclipse.jface.viewers.Viewer;
16	import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
17	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
18	import org.eclipse.mylyn.tasks.core.data.TaskData;
19
20	public class CommonViewerTaskDataContentProvider implements ITreeContentProvider {
21
22	private boolean showTaskAttributes;
23
24	public boolean isShowTaskAttributes() {
25	return showTaskAttributes;
26	}
27
28	public void setShowTaskAttributes(boolean showTaskAttributes) {
29	this.showTaskAttributes = showTaskAttributes;
30	}
31
32	public Object[] getChildren(Object parentElement) {
33	Object[] result = {};
34	if (parentElement instanceof TaskData) {
35	TaskData node = (TaskData) parentElement;
36	result = node.getRoot().getAttributes().values().toArray();
37	} else if (parentElement instanceof TaskAttribute) {
38	TaskAttribute node = (TaskAttribute) parentElement;
39	result = node.getAttributes().values().toArray();
40	} else if (parentElement instanceof TaskEditorOutlineNode) {
41	result = ((TaskEditorOutlineNode) parentElement).getChildren();
42	}
43	return result;
44	}
45
46	public Object[] getElements(Object inputElement) {
47	boolean b = TasksUiPlugin.getDefault()
48	.getPreferenceStore()
49	.getBoolean(ITasksUiPreferenceConstants.QUICKOUTLINE_TASKMODE_TASKDATA);
50
51	if (inputElement instanceof TaskData) {
52	if (b) {
53	return getChildren(inputElement);
54	} else {
55	TaskEditorOutlineNode node = TaskEditorOutlineNode.parse((TaskData) inputElement);
56	return node.getChildren();
57	}
58	}
59	return null;
60	}
61
62	/* (non-Javadoc)
63	* @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
64	*/
65	public Object getParent(Object element) {
66	if (element instanceof TaskData) {
67
68	return null;
69	} else if (element instanceof TaskAttribute) {
70	TaskAttribute node = (TaskAttribute) element;
71	return node.getParentAttribute();
72	} else if (element instanceof TaskEditorOutlineNode) {
73	return ((TaskEditorOutlineNode) element).getParent();
74	}
75	return null;
76	}
77
78	/* (non-Javadoc)
79	* @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
80	*/
81	public boolean hasChildren(Object element) {
82	if (element instanceof TaskData) {
83	TaskData node = (TaskData) element;
84	return node.getRoot().getAttributes().size() > 0;
85	} else if (element instanceof TaskAttribute) {
86	TaskAttribute node = (TaskAttribute) element;
87	return node.getAttributes().size() > 0;
88	} else if (element instanceof TaskEditorOutlineNode) {
89	return ((TaskEditorOutlineNode) element).getChildren().length > 0;
90	}
91	return false;
92	}
93
94	/* (non-Javadoc)
95	* @see org.eclipse.jface.viewers.IContentProvider#dispose()
96	*/
97	public void dispose() {
98	}
99
100	/* (non-Javadoc)
101	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
102	*/
103	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
104	}
105
106	}

Lines 25-30 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/EditorUtil.java (-5 / +75 lines)
25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;	25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
26	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;	26	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonThemes;
27	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;	27	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;
		28	import org.eclipse.mylyn.internal.tasks.core.TaskAttachment;
28	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;	29	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
29	import org.eclipse.mylyn.internal.tasks.ui.wizards.NewAttachmentWizardDialog;	30	import org.eclipse.mylyn.internal.tasks.ui.wizards.NewAttachmentWizardDialog;
30	import org.eclipse.mylyn.internal.tasks.ui.wizards.TaskAttachmentWizard.Mode;	31	import org.eclipse.mylyn.internal.tasks.ui.wizards.TaskAttachmentWizard.Mode;
Lines 32-37 Link Here
32	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;	33	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
33	import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;	34	import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
34	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;	35	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
		36	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPart;
35	import org.eclipse.mylyn.tasks.ui.editors.TaskFormPage;	37	import org.eclipse.mylyn.tasks.ui.editors.TaskFormPage;
36	import org.eclipse.swt.SWT;	38	import org.eclipse.swt.SWT;
37	import org.eclipse.swt.custom.CCombo;	39	import org.eclipse.swt.custom.CCombo;
Lines 58-63 Link Here
58	import org.eclipse.swt.widgets.Menu;	60	import org.eclipse.swt.widgets.Menu;
59	import org.eclipse.swt.widgets.ScrollBar;	61	import org.eclipse.swt.widgets.ScrollBar;
60	import org.eclipse.swt.widgets.Scrollable;	62	import org.eclipse.swt.widgets.Scrollable;
		63	import org.eclipse.swt.widgets.TableItem;
61	import org.eclipse.swt.widgets.Widget;	64	import org.eclipse.swt.widgets.Widget;
62	import org.eclipse.ui.PlatformUI;	65	import org.eclipse.ui.PlatformUI;
63	import org.eclipse.ui.actions.ActionFactory;	66	import org.eclipse.ui.actions.ActionFactory;
Lines 153-159 Link Here
153	* @param control	156	* @param control
154	* The StyledText to scroll to	157	* The StyledText to scroll to
155	*/	158	*/
156	private static void focusOn(ScrolledForm form, Control control) {	159	public static void focusOn(ScrolledForm form, Control control) {
157	int pos = 0;	160	int pos = 0;
158	control.setEnabled(true);	161	control.setEnabled(true);
159	control.setFocus();	162	control.setFocus();
Lines 405-412 Link Here
405	} else {	408	} else {
406	roundedBorder.setLayout(GridLayoutFactory.fillDefaults().margins(0, 6).create());	409	roundedBorder.setLayout(GridLayoutFactory.fillDefaults().margins(0, 6).create());
407	}	410	}
408	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.BEGINNING).hint(EditorUtil.MAXIMUM_WIDTH, SWT.DEFAULT).grab(	411	GridDataFactory.fillDefaults()
409	true, false).applyTo(roundedBorder);	412	.align(SWT.FILL, SWT.BEGINNING)
		413	.hint(EditorUtil.MAXIMUM_WIDTH, SWT.DEFAULT)
		414	.grab(true, false)
		415	.applyTo(roundedBorder);
410	return roundedBorder;	416	return roundedBorder;
411	}	417	}
412		418
Lines 432-439 Link Here
432	textFont.dispose();	438	textFont.dispose();
433	}	439	}
434	});	440	});
435	Color color = PlatformUI.getWorkbench().getThemeManager().getCurrentTheme().getColorRegistry().get(	441	Color color = PlatformUI.getWorkbench()
436	CommonThemes.COLOR_COMPLETED);	442	.getThemeManager()
		443	.getCurrentTheme()
		444	.getColorRegistry()
		445	.get(CommonThemes.COLOR_COMPLETED);
437	text.setForeground(color);	446	text.setForeground(color);
438	return textFont;	447	return textFont;
439	}	448	}
Lines 590-593 Link Here
590	}	599	}
591	}	600	}
592		601
		602	public static void focusFromStructuredSelection(Object select, AbstractTaskEditorPage taskEditorPage) {
		603	if (select instanceof TaskEditorOutlineNode) {
		604	TaskEditorOutlineNode node = (TaskEditorOutlineNode) select;
		605	TaskAttribute attribute = node.getData();
		606	if (attribute != null) {
		607	if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
		608	AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_COMMENTS);
		609	if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
		610	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
		611	if (actionPart.getControl() instanceof Section) {
		612	Control client = ((Section) actionPart.getControl()).getClient();
		613	if (client instanceof Composite) {
		614	for (Control control : ((Composite) client).getChildren()) {
		615	// toggle subsections
		616	if (control instanceof Section) {
		617	CommonFormUtil.setExpanded((Section) control, true);
		618	}
		619	}
		620	}
		621	}
		622	}
		623	taskEditorPage.reveal(attribute.getId());
		624	} else if (TaskAttribute.TYPE_ATTACHMENT.equals(attribute.getMetaData().getType())) {
		625	AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTACHMENTS);
		626	if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
		627	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
		628	if (actionPart.getControl() instanceof Section) {
		629	Control client = actionPart.getControl();
		630	if (client instanceof Composite) {
		631	for (Control control : ((Composite) client).getChildren()) {
		632	if (control instanceof Composite) {
		633	for (Control control1 : ((Composite) control).getChildren()) {
		634	if (control1 instanceof org.eclipse.swt.widgets.Table) {
		635	org.eclipse.swt.widgets.Table attachmentTable = ((org.eclipse.swt.widgets.Table) control1);
		636	TableItem[] attachments = attachmentTable.getItems();
		637	int index = 0;
		638	for (TableItem attachment : attachments) {
		639	TaskAttachment attachmentData = ((TaskAttachment) attachment.getData());
		640	if (attachmentData.getTaskAttribute() == attribute) {
		641	attachmentTable.deselectAll();
		642	attachmentTable.select(index);
		643	IManagedForm mform = actionPart.getManagedForm();
		644	ScrolledForm form = mform.getForm();
		645	EditorUtil.focusOn(form, attachmentTable);
		646	break;
		647	}
		648	index++;
		649	}
		650	}
		651	}
		652	}
		653	}
		654	}
		655	}
		656	}
		657	}
		658	} else {
		659	taskEditorPage.reveal(node.getLabel());
		660	}
		661	}
		662	}
593	}	663	}

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorOutlineNodeLabelProvider.java (+96 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 Frank Beckers 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	* Frank Becker - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.tasks.ui.editors;
13
14	import org.eclipse.jface.viewers.LabelProvider;
15	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
16	import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;
17	import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
18	import org.eclipse.mylyn.tasks.core.ITaskAttachment;
19	import org.eclipse.mylyn.tasks.core.TaskRepository;
20	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
21	import org.eclipse.mylyn.tasks.ui.TasksUi;
22	import org.eclipse.mylyn.tasks.ui.TasksUiImages;
23	import org.eclipse.swt.graphics.Image;
24	import org.eclipse.ui.ISharedImages;
25	import org.eclipse.ui.internal.WorkbenchImages;
26
27	public class TaskEditorOutlineNodeLabelProvider extends LabelProvider {
28	private static final String[] IMAGE_EXTENSIONS = { "jpg", "gif", "png", "tiff", "tif", "bmp" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ @Override
29
30	@Override
31	public Image getImage(Object element) {
32	if (element instanceof TaskEditorOutlineNode) {
33	TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
34	if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
35	\|\| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())) {
36	return CommonImages.getImage(TasksUiImages.COMMENT);
37	}
38	if (TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
39	return CommonImages.getImage(TasksUiImages.TASK_NOTES);
40	} else if (node.getTaskComment() != null) {
41	IRepositoryPerson author = node.getTaskComment().getAuthor();
42	TaskAttribute taskAttribute = node.getData();
43	String repositoryUrl = taskAttribute.getTaskData().getRepositoryUrl();
44	String connectorKind = null;
45	TaskRepository taskRepository = null;
46	if (repositoryUrl != null) {
47	connectorKind = taskAttribute.getTaskData().getConnectorKind();
48	if (connectorKind != null) {
49	taskRepository = TasksUi.getRepositoryManager().getRepository(connectorKind, repositoryUrl);
50	}
51	}
52	if (taskRepository != null && author != null
53	&& author.getPersonId().equals(taskRepository.getUserName())) {
54	return CommonImages.getImage(CommonImages.PERSON_ME);
55	} else {
56	return CommonImages.getImage(CommonImages.PERSON);
57	}
58	} else if (node.getTaskAttachment() != null) {
59	ITaskAttachment attachment = node.getTaskAttachment();
60	if (AttachmentUtil.isContext(attachment)) {
61	return CommonImages.getImage(TasksUiImages.CONTEXT_TRANSFER);
62	} else if (attachment.isPatch()) {
63	return CommonImages.getImage(TasksUiImages.TASK_ATTACHMENT_PATCH);
64	} else {
65	String filename = attachment.getFileName();
66	if (filename != null) {
67	int dotIndex = filename.lastIndexOf('.');
68	if (dotIndex != -1) {
69	String fileType = filename.substring(dotIndex + 1);
70	for (String element2 : IMAGE_EXTENSIONS) {
71	if (element2.equalsIgnoreCase(fileType)) {
72	return CommonImages.getImage(CommonImages.IMAGE_FILE);
73	}
74	}
75	}
76	}
77	return WorkbenchImages.getImage(ISharedImages.IMG_OBJ_FILE);
78	}
79	} else {
80	return CommonImages.getImage(TasksUiImages.TASK);
81	}
82	} else {
83	return super.getImage(element);
84	}
85	}
86
87	@Override
88	public String getText(Object element) {
89	if (element instanceof TaskEditorOutlineNode) {
90	TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
91	return node.getLabel();
92	}
93	return super.getText(element);
94	}
95
96	}