Attachment #169720 for bug #278102

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 631-637 Link Here

(-)plugin.xml (-1 / +19 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	commandId="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		636	contextId="org.eclipse.mylyn.tasks.ui.editors.task"
		637	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
		638	sequence="M1+M2+O">
		639	</key>
		640	</extension>
635		641
636	<extension	642	<extension
637	point="org.eclipse.ui.themes">	643	point="org.eclipse.ui.themes">
Lines 828-833 Link Here
828	style="push"	834	style="push"
829	toolbarPath="org.eclipse.search.searchActionSet/Search"	835	toolbarPath="org.eclipse.search.searchActionSet/Search"
830	tooltip="%OpenTaskAction.tooltip"/>	836	tooltip="%OpenTaskAction.tooltip"/>
		837	<action
		838	definitionId="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		839	label="Quick Outline"
		840	class="org.eclipse.mylyn.internal.tasks.ui.editors.outline.ShowQuickOutlineAction"
		841	menubarPath="navigate/showIn"
		842	id="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog">
		843	</action>
831	</actionSet>	844	</actionSet>
832	</extension>	845	</extension>
833		846
Lines 835-840 Link Here
835	<command id="org.eclipse.mylyn.tasks.ui.command.previousTask"	848	<command id="org.eclipse.mylyn.tasks.ui.command.previousTask"
836	defaultHandler="org.eclipse.mylyn.internal.tasks.ui.TaskHistoryHandler"	849	defaultHandler="org.eclipse.mylyn.internal.tasks.ui.TaskHistoryHandler"
837	name="%command.previousTask.name"/>	850	name="%command.previousTask.name"/>
		851	<command
		852	name="Quick Outline"
		853	description="Show the quick outline for the editor input"
		854	id="org.eclipse.mylyn.task.ui.actions.outline.related.tasks.dialog"
		855	categoryId="org.eclipse.mylyn.tasks.ui.commands"/>
838	</extension>	856	</extension>
839		857
840	<!-- command-based implementation of the previousTask/history dropdown,	858	<!-- command-based implementation of the previousTask/history dropdown,




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.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.AbstractTaskAttachmentSource;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskRelation;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
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);
									}
								}
							}
						}
					}
					EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), 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 {
					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);
						}
					}

					EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), attribute.getId());
				}
			} else {
				TaskRelation taskRelation = node.getTaskRelation();
				TaskRepository taskRepository = node.getTaskRepository();
				if (taskRelation != null && taskRepository != null) {
					String taskID = taskRelation.getTaskId();
					TasksUiUtil.openTask(taskRepository, taskID);
				} else {
					EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), node.getLabel());
				}
			}
		}
	}
}

Lines 151-164 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/Messages.java (+10 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
		156	public static String TaskEditorOutlineNode_Attributes;
		157
154	public static String TaskEditorOutlineNode_Comments;	158	public static String TaskEditorOutlineNode_Comments;
155		159
156	public static String TaskEditorOutlineNode_Description;	160	public static String TaskEditorOutlineNode_Description;
157		161
158	public static String TaskEditorOutlineNode_New_Comment;	162	public static String TaskEditorOutlineNode_New_Comment;
159		163
		164	public static String TaskEditorOutlineNode_Related_Tasks;
		165
160	public static String TaskEditorOutlineNode_Task_;	166	public static String TaskEditorOutlineNode_Task_;
161		167
		168	public static String TaskEditorOutlineNode_TaskRelation_Label;
		169
		170	public static String TaskEditorOutlineNode_unknown_Label;
		171
162	public static String TaskEditorPeoplePart_People;	172	public static String TaskEditorPeoplePart_People;
163		173
164	public static String TaskEditorPlanningPart_0_SECOUNDS;	174	public static String TaskEditorPlanningPart_0_SECOUNDS;




/*******************************************************************************
 * Copyright (c) 2010 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.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

public class TaskEditorOutlineContentProvider implements ITreeContentProvider {

	public void dispose() {
		// ignore
	}

	public Object[] getChildren(Object parentElement) {
		if (parentElement instanceof TaskEditorOutlineNode) {
			Object[] children = ((TaskEditorOutlineNode) parentElement).getChildren();
			return children;
		}
		return new Object[0];
	}

	public Object[] getElements(Object inputElement) {
		if (inputElement instanceof TaskEditorOutlineModel) {
			return new Object[] { ((TaskEditorOutlineModel) inputElement).getRoot() };
		}
		return new Object[0];
	}

	public Object getParent(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			return ((TaskEditorOutlineNode) element).getParent();
		}
		return null;
	}

	public boolean hasChildren(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			return ((TaskEditorOutlineNode) element).getChildren().length > 0;
		}
		return false;
	}

	public void inputChanged(Viewer viewerChanged, Object oldInput, Object newInput) {
		// ignore
	}

}




/*******************************************************************************
 * Copyright (c) 2010 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;

public class TaskEditorOutlineModel {

	private final TaskEditorOutlineNode root;

	public TaskEditorOutlineModel(TaskEditorOutlineNode root) {
		this.root = root;
	}

	public TaskEditorOutlineNode getRoot() {
		return root;
	}

}

Lines 12-26 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorOutlineNode.java (-2 / +121 lines)
12	package org.eclipse.mylyn.internal.tasks.ui.editors;	12	package org.eclipse.mylyn.internal.tasks.ui.editors;
13		13
14	import java.util.ArrayList;	14	import java.util.ArrayList;
		15	import java.util.Collection;
15	import java.util.Date;	16	import java.util.Date;
16	import java.util.List;	17	import java.util.List;
		18	import java.util.Map;
17		19
18	import org.eclipse.core.runtime.Assert;	20	import org.eclipse.core.runtime.Assert;
		21	import org.eclipse.mylyn.internal.tasks.core.TaskList;
		22	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
19	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;	23	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
		24	import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;
		25	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
20	import org.eclipse.mylyn.tasks.core.IRepositoryPerson;	26	import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
		27	import org.eclipse.mylyn.tasks.core.ITask;
		28	import org.eclipse.mylyn.tasks.core.ITaskAttachment;
21	import org.eclipse.mylyn.tasks.core.ITaskComment;	29	import org.eclipse.mylyn.tasks.core.ITaskComment;
		30	import org.eclipse.mylyn.tasks.core.TaskRepository;
22	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;	31	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
23	import org.eclipse.mylyn.tasks.core.data.TaskData;	32	import org.eclipse.mylyn.tasks.core.data.TaskData;
		33	import org.eclipse.mylyn.tasks.core.data.TaskRelation;
		34	import org.eclipse.mylyn.tasks.ui.TasksUi;
		35	import org.eclipse.osgi.util.NLS;
24		36
25	/**	37	/**
26	* A node for the tree in {@link TaskEditorOutlinePage}.	38	* A node for the tree in {@link TaskEditorOutlinePage}.
Lines 35-40 Link Here
35		47
36	public static final String LABEL_NEW_COMMENT = Messages.TaskEditorOutlineNode_New_Comment;	48	public static final String LABEL_NEW_COMMENT = Messages.TaskEditorOutlineNode_New_Comment;
37		49
		50	public static final String LABEL_ATTACHMENTS = Messages.TaskEditorOutlineNode_Attachments;
		51
		52	public static final String LABEL_ATTRIBUTES = Messages.TaskEditorOutlineNode_Attributes;
		53
		54	public static final String LABEL_RELATED_TASKS = Messages.TaskEditorOutlineNode_Related_Tasks;
		55
38	private static TaskEditorOutlineNode createNode(TaskData taskData, String attributeId, String label) {	56	private static TaskEditorOutlineNode createNode(TaskData taskData, String attributeId, String label) {
39	TaskAttribute taskAttribute = taskData.getRoot().getMappedAttribute(attributeId);	57	TaskAttribute taskAttribute = taskData.getRoot().getMappedAttribute(attributeId);
40	if (taskAttribute != null) {	58	if (taskAttribute != null) {
Lines 69-87 Link Here
69	node.setTaskComment(taskComment);	87	node.setTaskComment(taskComment);
70	return node;	88	return node;
71	}	89	}
		90	} else if (TaskAttribute.TYPE_ATTACHMENT.equals(type)) {
		91	ITaskAttachment taskAttachment = TasksUiPlugin.getRepositoryModel().createTaskAttachment(taskAttribute);
		92	if (taskAttachment != null) {
		93	taskAttribute.getTaskData().getAttributeMapper().updateTaskAttachment(taskAttachment, taskAttribute);
		94	StringBuilder sb = new StringBuilder();
		95	sb.append(taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute));
		96	sb.append(": "); //$NON-NLS-1$
		97	if (AttachmentUtil.isContext(taskAttachment)) {
		98	sb.append(Messages.AttachmentTableLabelProvider_Task_Context);
		99	} else if (taskAttachment.isPatch()) {
		100	sb.append(Messages.AttachmentTableLabelProvider_Patch);
		101	} else {
		102	sb.append(taskAttachment.getFileName());
		103	}
		104	TaskEditorOutlineNode node = new TaskEditorOutlineNode(sb.toString(), taskAttribute);
		105	node.setTaskAttachment(taskAttachment);
		106	return node;
		107	}
72	} else {	108	} else {
73	String label = taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute);	109	String label = taskAttribute.getTaskData().getAttributeMapper().getLabel(taskAttribute);
		110	if (label.endsWith(":")) { //$NON-NLS-1$
		111	label = label.substring(0, label.length() - 1);
		112	}
74	return new TaskEditorOutlineNode(label, taskAttribute);	113	return new TaskEditorOutlineNode(label, taskAttribute);
75	}	114	}
76	return null;	115	return null;
77	}	116	}
78		117
79	public static TaskEditorOutlineNode parse(TaskData taskData) {	118	public static TaskEditorOutlineNode parse(TaskData taskData, boolean includeAttributes) {
80	TaskEditorOutlineNode rootNode = createNode(taskData, TaskAttribute.SUMMARY, null);	119	TaskEditorOutlineNode rootNode = createNode(taskData, TaskAttribute.SUMMARY, null);
81	if (rootNode == null) {	120	if (rootNode == null) {
82	rootNode = new TaskEditorOutlineNode(Messages.TaskEditorOutlineNode_Task_ + taskData.getTaskId());	121	rootNode = new TaskEditorOutlineNode(Messages.TaskEditorOutlineNode_Task_ + taskData.getTaskId());
83	}	122	}
		123	if (includeAttributes) {
		124	final TaskList taskList = TasksUiPlugin.getTaskList();
		125	TaskEditorOutlineNode relatedTasksNode = new TaskEditorOutlineNode(LABEL_RELATED_TASKS);
		126	rootNode.addChild(relatedTasksNode);
		127	AbstractRepositoryConnector connector = TasksUi.getRepositoryConnector(taskData.getConnectorKind());
		128	Collection<TaskRelation> relations = connector.getTaskRelations(taskData);
		129	TaskRepositoryManager manager = TasksUiPlugin.getRepositoryManager();
		130	TaskRepository taskRepository = manager.getRepository(taskData.getConnectorKind(),
		131	taskData.getRepositoryUrl());
		132	for (TaskRelation taskRelation : relations) {
		133	ITask task = taskList.getTask(taskData.getRepositoryUrl(), taskRelation.getTaskId());
		134	String label;
		135	if (task != null) {
		136	label = NLS.bind(Messages.TaskEditorOutlineNode_TaskRelation_Label,
		137	new Object[] { taskRelation.getTaskId(), task.getSummary() });
		138	} else {
		139	label = NLS.bind(Messages.TaskEditorOutlineNode_TaskRelation_Label,
		140	new Object[] { taskRelation.getTaskId(), Messages.TaskEditorOutlineNode_unknown_Label });
		141	}
		142	TaskEditorOutlineNode childNode = new TaskEditorOutlineNode(label);
		143
		144	childNode.setTaskRelation(taskRelation);
		145	childNode.setTaskRepository(taskRepository);
		146	relatedTasksNode.addChild(childNode);
		147	}
		148
		149	TaskEditorOutlineNode attributesNode = new TaskEditorOutlineNode(LABEL_ATTRIBUTES);
		150	rootNode.addChild(attributesNode);
		151	Map<String, TaskAttribute> attributes = taskData.getRoot().getAttributes();
		152	for (TaskAttribute attribute : attributes.values()) {
		153	if (TaskAttribute.KIND_DEFAULT.equals(attribute.getMetaData().getKind())) {
		154	TaskEditorOutlineNode node = createNode(attribute);
		155	if (node != null) {
		156	attributesNode.addChild(node);
		157	}
		158	}
		159	}
		160	}
84	addNode(rootNode, taskData, TaskAttribute.DESCRIPTION, LABEL_DESCRIPTION);	161	addNode(rootNode, taskData, TaskAttribute.DESCRIPTION, LABEL_DESCRIPTION);
		162	List<TaskAttribute> attachments = taskData.getAttributeMapper().getAttributesByType(taskData,
		163	TaskAttribute.TYPE_ATTACHMENT);
		164	if (attachments.size() > 0) {
		165	TaskEditorOutlineNode attachmentNode = new TaskEditorOutlineNode(LABEL_ATTACHMENTS);
		166	rootNode.addChild(attachmentNode);
		167	for (TaskAttribute attachmentAttribute : attachments) {
		168	TaskEditorOutlineNode node = createNode(attachmentAttribute);
		169	if (node != null) {
		170	attachmentNode.addChild(node);
		171	}
		172	}
		173	}
85	List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData,	174	List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData,
86	TaskAttribute.TYPE_COMMENT);	175	TaskAttribute.TYPE_COMMENT);
87	if (comments.size() > 0) {	176	if (comments.size() > 0) {
Lines 118-123 Link Here
118		207
119	private ITaskComment taskComment;	208	private ITaskComment taskComment;
120		209
		210	private ITaskAttachment taskAttachment;
		211
		212	private TaskRelation taskRelation;
		213
		214	private TaskRepository taskRepository;
		215
121	public TaskEditorOutlineNode(String label) {	216	public TaskEditorOutlineNode(String label) {
122	this(label, null);	217	this(label, null);
123	}	218	}
Lines 183-186 Link Here
183	return getLabel();	278	return getLabel();
184	}	279	}
185		280
		281	public ITaskAttachment getTaskAttachment() {
		282	return taskAttachment;
		283	}
		284
		285	public void setTaskAttachment(ITaskAttachment taskAttachment) {
		286	this.taskAttachment = taskAttachment;
		287	}
		288
		289	public TaskRelation getTaskRelation() {
		290	return taskRelation;
		291	}
		292
		293	public void setTaskRelation(TaskRelation taskRelation) {
		294	this.taskRelation = taskRelation;
		295	}
		296
		297	public TaskRepository getTaskRepository() {
		298	return taskRepository;
		299	}
		300
		301	public void setTaskRepository(TaskRepository taskRepository) {
		302	this.taskRepository = taskRepository;
		303	}
		304
186	}	305	}




/*******************************************************************************
 * 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.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;

/**
 * @author Frank Becker
 */
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 if (node.getData() != null) {
				return super.getImage(element);
			} 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;
			if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
					|| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())
					|| TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
				return node.getLabel();
			}
			if (node.getData() != null && node.getTaskAttachment() == null && node.getTaskComment() == null) {
				// regular attribute
				TaskAttribute taskAttribute = node.getData();
				String label = taskAttribute.getTaskData().getAttributeMapper().getLabel(taskAttribute);
				if (!label.endsWith(":")) { //$NON-NLS-1$
					label += ":"; //$NON-NLS-1$
				}
				return label + " " + taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute); //$NON-NLS-1$
			}
			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;


 */
public class TaskEditorOutlinePage extends ContentOutlinePage {

	private static class TaskEditorOutlineContentProvider implements ITreeContentProvider {

		public void dispose() {
			// ignore
		}

		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof TaskEditorOutlineNode) {
				Object[] children = ((TaskEditorOutlineNode) parentElement).getChildren();
				return children;
			}
			return new Object[0];
		}

		public Object[] getElements(Object inputElement) {
			if (inputElement instanceof TaskEditorOutlineModel) {
				return new Object[] { ((TaskEditorOutlineModel) inputElement).getRoot() };
			}
			return new Object[0];
		}

		public Object getParent(Object element) {
			if (element instanceof TaskEditorOutlineNode) {
				return ((TaskEditorOutlineNode) element).getParent();
			}
			return null;
		}

		public boolean hasChildren(Object element) {
			if (element instanceof TaskEditorOutlineNode) {
				return ((TaskEditorOutlineNode) element).getChildren().length > 0;
			}
			return false;
		}

		public void inputChanged(Viewer viewerChanged, Object oldInput, Object newInput) {
			// ignore
		}

	}

	private static class TaskEditorOutlineModel {

		private final TaskEditorOutlineNode root;

		public TaskEditorOutlineModel(TaskEditorOutlineNode root) {
			this.root = root;
		}

		public TaskEditorOutlineNode getRoot() {
			return root;
		}

	}

	private TaskEditorOutlineModel model;

	private TaskRepository taskRepository;

		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-92 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/messages.properties (+5 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
		87	TaskEditorOutlineNode_Attributes=Attributes
86	TaskEditorOutlineNode_Comments=Comments	88	TaskEditorOutlineNode_Comments=Comments
87	TaskEditorOutlineNode_Description=Description	89	TaskEditorOutlineNode_Description=Description
88	TaskEditorOutlineNode_New_Comment=New Comment	90	TaskEditorOutlineNode_New_Comment=New Comment
		91	TaskEditorOutlineNode_Related_Tasks=Related Tasks
89	TaskEditorOutlineNode_Task_=Task	92	TaskEditorOutlineNode_Task_=Task
		93	TaskEditorOutlineNode_TaskRelation_Label={0}: {1}
		94	TaskEditorOutlineNode_unknown_Label=<unknown>
90		95
91	TaskEditorPeoplePart_People=People	96	TaskEditorPeoplePart_People=People
92		97




/*******************************************************************************
 * 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.editors.outline;

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.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.tasks.ui.editors.EditorUtil;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineContentProvider;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineModel;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
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.MouseListener;
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.Composite;
import org.eclipse.swt.widgets.Control;
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.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.dialogs.PatternFilter;
import org.eclipse.ui.forms.editor.IFormPage;

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

	private class OpenListener implements IOpenListener, IDoubleClickListener, MouseListener {

		private final Viewer viewer;

		public OpenListener(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);
		}

		public void open(OpenEvent event) {
			AbstractTaskEditorPage taskEditorPage = getTaskEditorPage();
			if (taskEditorPage == null) {
				return;
			}

			StructuredSelection selection = (StructuredSelection) viewer.getSelection();
			Object select = (selection).getFirstElement();
			EditorUtil.focusFromStructuredSelection(select, 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
			}
		}

	}

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

	private TreeViewer viewer;

	private Text filterText;

	private PatternFilter namePatternFilter;

	private OpenListener openListener;

	private final IWorkbenchWindow window;

	public QuickOutlineDialog(IWorkbenchWindow window) {
		super(window.getShell(), SWT.RESIZE, true, true, true, true, true, null, "Press ''Esc'' to exit the dialog.");
		this.window = window;
		create();
	}

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

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

		return viewer.getControl();
	}

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

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

		namePatternFilter = new PatternFilter();
		namePatternFilter.setIncludeLeadingWildcard(true);
		viewer.addFilter(namePatternFilter);

		AbstractTaskEditorPage taskEditorPage = getTaskEditorPage();
		if (taskEditorPage != null) {
			try {
				viewer.getControl().setRedraw(false);
				TaskEditorOutlineNode root = TaskEditorOutlineNode.parse(taskEditorPage.getModel().getTaskData(), true);
				viewer.setInput(new TaskEditorOutlineModel(root));
				viewer.expandAll();
			} finally {
				viewer.getControl().setRedraw(true);
			}
		}
	}

	protected TreeViewer createCommonViewer(Composite parent) {
		TreeViewer viewer = new TreeViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL);
		viewer.setUseHashlookup(true);
		viewer.getControl().setLayoutData(new GridData(500, 400));
		viewer.setContentProvider(new TaskEditorOutlineContentProvider());
		viewer.setLabelProvider(new QuickOutlineLabelProvider());
		return viewer;
	}

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

	private void createUIListenersTreeViewer() {
		final Tree tree = viewer.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 (viewer == null) {
			return null;
		}
		return ((IStructuredSelection) viewer.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 (viewer.getControl().isFocusControl() || filterText.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();
		filterText.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 ((viewer == null) || (viewer.getInput() == null)) {
			return false;
		}
		return true;
	}

	public void setInput(Object input) {
		if (input != null) {
			viewer.setSelection(new StructuredSelection(input));
		}
	}

	public void widgetDisposed(DisposeEvent e) {
		// Note: We do not reuse the dialog
		viewer = null;
		filterText = 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();
		// Return the text widget
		return control;
	}

	private void createUIWidgetFilterText(Composite parent) {
		// Create the widget
		filterText = 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;
		filterText.setLayoutData(data);
	}

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

	private void createUIListenersFilterText() {
		filterText.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
					viewer.getTree().setFocus();
				} else if (e.keyCode == SWT.ARROW_UP) {
					// Up key was pressed
					viewer.getTree().setFocus();
				} else if (e.character == 0x1B) {
					// Escape key was pressed
					dispose();
				}
			}

			public void keyReleased(KeyEvent e) {
				// NO-OP
			}
		});
		// Handle text modify events
		filterText.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) {
		namePatternFilter.setPattern(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
		viewer.getControl().setRedraw(false);
		viewer.refresh();
		viewer.expandAll();
//		selectFirstMatch();
		viewer.getControl().setRedraw(true);
	}

	protected AbstractTaskEditorPage getTaskEditorPage() {
		IWorkbenchPage activePage = window.getActivePage();
		if (activePage == null) {
			return null;
		}
		IEditorPart editorPart = activePage.getActiveEditor();
		AbstractTaskEditorPage taskEditorPage = null;
		if (editorPart instanceof TaskEditor) {
			TaskEditor taskEditor = (TaskEditor) editorPart;
			IFormPage formPage = taskEditor.getActivePageInstance();
			if (formPage instanceof AbstractTaskEditorPage) {
				taskEditorPage = (AbstractTaskEditorPage) formPage;
			}
		}
		return taskEditorPage;
	}

//	/**
//	 * Selects the first element in the tree which matches the current filter pattern.
//	 */
//	private void selectFirstMatch() {
//		Tree tree = viewer.getTree();
//		Object element = findFirstMatchToPattern(tree.getItems());
//		if (element != null) {
//			viewer.setSelection(new StructuredSelection(element), true);
//		} else {
//			viewer.setSelection(StructuredSelection.EMPTY);
//		}
//	}
//
//	/**
//	 * @param items
//	 * @return
//	 */
//	private Object findFirstMatchToPattern(TreeItem[] items) {
//		// Match the string pattern against labels
//		ILabelProvider labelProvider = (ILabelProvider) viewer.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;
//	}

}




/*******************************************************************************
 * 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.editors.outline;

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;

/**
 * @author Frank Becker
 */
public class QuickOutlineLabelProvider 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() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
				} 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;
	}

	@Override
	public Image getImage(Object element) {
		if (element instanceof TaskEditorOutlineNode) {
			return super.getImage(element);
		} else {
			return null;
		}
	}

}




/*******************************************************************************
 * 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.editors.outline;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

/**
 * @author Frank Becker
 */
public class ShowQuickOutlineAction implements IWorkbenchWindowActionDelegate {

	private QuickOutlineDialog inplaceDialog;

	private IWorkbenchWindow window;

	public void run(IAction action) {
		inplaceDialog = new QuickOutlineDialog(window);
		inplaceDialog.open();
		inplaceDialog.setFocus();
	}

	public void dispose() {
		inplaceDialog = null;
	}

	public void init(IWorkbenchWindow window) {
		this.window = window;
	}

	public void selectionChanged(IAction action, ISelection selection) {
		// ignore
	}

}




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 (getModel() != null) {
			TaskEditorOutlineNode node = TaskEditorOutlineNode.parse(getModel().getTaskData(), false);
			outlinePage.setInput(getTaskRepository(), node);
		} else {
			outlinePage.setInput(null, null);

			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

Return to bug 278102

Lines 25-37 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/EditorUtil.java (-5 / +97 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;
		32	import org.eclipse.mylyn.tasks.core.TaskRepository;
31	import org.eclipse.mylyn.tasks.core.data.AbstractTaskAttachmentSource;	33	import org.eclipse.mylyn.tasks.core.data.AbstractTaskAttachmentSource;
32	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;	34	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
33	import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;	35	import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
		36	import org.eclipse.mylyn.tasks.core.data.TaskRelation;
		37	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
34	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;	38	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
		39	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPart;
35	import org.eclipse.mylyn.tasks.ui.editors.TaskFormPage;	40	import org.eclipse.mylyn.tasks.ui.editors.TaskFormPage;
36	import org.eclipse.swt.SWT;	41	import org.eclipse.swt.SWT;
37	import org.eclipse.swt.custom.CCombo;	42	import org.eclipse.swt.custom.CCombo;
Lines 58-63 Link Here
58	import org.eclipse.swt.widgets.Menu;	63	import org.eclipse.swt.widgets.Menu;
59	import org.eclipse.swt.widgets.ScrollBar;	64	import org.eclipse.swt.widgets.ScrollBar;
60	import org.eclipse.swt.widgets.Scrollable;	65	import org.eclipse.swt.widgets.Scrollable;
		66	import org.eclipse.swt.widgets.TableItem;
61	import org.eclipse.swt.widgets.Widget;	67	import org.eclipse.swt.widgets.Widget;
62	import org.eclipse.ui.PlatformUI;	68	import org.eclipse.ui.PlatformUI;
63	import org.eclipse.ui.actions.ActionFactory;	69	import org.eclipse.ui.actions.ActionFactory;
Lines 153-159 Link Here
153	* @param control	159	* @param control
154	* The StyledText to scroll to	160	* The StyledText to scroll to
155	*/	161	*/
156	private static void focusOn(ScrolledForm form, Control control) {	162	public static void focusOn(ScrolledForm form, Control control) {
157	int pos = 0;	163	int pos = 0;
158	control.setEnabled(true);	164	control.setEnabled(true);
159	control.setFocus();	165	control.setFocus();
Lines 405-412 Link Here
405	} else {	411	} else {
406	roundedBorder.setLayout(GridLayoutFactory.fillDefaults().margins(0, 6).create());	412	roundedBorder.setLayout(GridLayoutFactory.fillDefaults().margins(0, 6).create());
407	}	413	}
408	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.BEGINNING).hint(EditorUtil.MAXIMUM_WIDTH, SWT.DEFAULT).grab(	414	GridDataFactory.fillDefaults()
409	true, false).applyTo(roundedBorder);	415	.align(SWT.FILL, SWT.BEGINNING)
		416	.hint(EditorUtil.MAXIMUM_WIDTH, SWT.DEFAULT)
		417	.grab(true, false)
		418	.applyTo(roundedBorder);
410	return roundedBorder;	419	return roundedBorder;
411	}	420	}
412		421
Lines 432-439 Link Here
432	textFont.dispose();	441	textFont.dispose();
433	}	442	}
434	});	443	});
435	Color color = PlatformUI.getWorkbench().getThemeManager().getCurrentTheme().getColorRegistry().get(	444	Color color = PlatformUI.getWorkbench()
436	CommonThemes.COLOR_COMPLETED);	445	.getThemeManager()
		446	.getCurrentTheme()
		447	.getColorRegistry()
		448	.get(CommonThemes.COLOR_COMPLETED);
437	text.setForeground(color);	449	text.setForeground(color);
438	return textFont;	450	return textFont;
439	}	451	}
Lines 590-593 Link Here
590	}	602	}
591	}	603	}
592		604
		605	public static void focusFromStructuredSelection(Object select, AbstractTaskEditorPage taskEditorPage) {
		606	if (select instanceof TaskEditorOutlineNode) {
		607	TaskEditorOutlineNode node = (TaskEditorOutlineNode) select;
		608	TaskAttribute attribute = node.getData();
		609	if (attribute != null) {
		610	if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
		611	AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_COMMENTS);
		612	if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
		613	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
		614	if (actionPart.getControl() instanceof Section) {
		615	Control client = ((Section) actionPart.getControl()).getClient();
		616	if (client instanceof Composite) {
		617	for (Control control : ((Composite) client).getChildren()) {
		618	// toggle subsections
		619	if (control instanceof Section) {
		620	CommonFormUtil.setExpanded((Section) control, true);
		621	}
		622	}
		623	}
		624	}
		625	}
		626	EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), attribute.getId());
		627	} else if (TaskAttribute.TYPE_ATTACHMENT.equals(attribute.getMetaData().getType())) {
		628	AbstractTaskEditorPart actionPart = taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTACHMENTS);
		629	if (actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
		630	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
		631	if (actionPart.getControl() instanceof Section) {
		632	Control client = actionPart.getControl();
		633	if (client instanceof Composite) {
		634	for (Control control : ((Composite) client).getChildren()) {
		635	if (control instanceof Composite) {
		636	for (Control control1 : ((Composite) control).getChildren()) {
		637	if (control1 instanceof org.eclipse.swt.widgets.Table) {
		638	org.eclipse.swt.widgets.Table attachmentTable = ((org.eclipse.swt.widgets.Table) control1);
		639	TableItem[] attachments = attachmentTable.getItems();
		640	int index = 0;
		641	for (TableItem attachment : attachments) {
		642	TaskAttachment attachmentData = ((TaskAttachment) attachment.getData());
		643	if (attachmentData.getTaskAttribute() == attribute) {
		644	attachmentTable.deselectAll();
		645	attachmentTable.select(index);
		646	IManagedForm mform = actionPart.getManagedForm();
		647	ScrolledForm form = mform.getForm();
		648	EditorUtil.focusOn(form, attachmentTable);
		649	break;
		650	}
		651	index++;
		652	}
		653	}
		654	}
		655	}
		656	}
		657	}
		658	}
		659	}
		660	} else {
		661	TaskEditorAttributePart actionPart = (TaskEditorAttributePart) taskEditorPage.getPart(AbstractTaskEditorPage.ID_PART_ATTRIBUTES);
		662	Section section = actionPart.getSection();
		663	boolean expanded = section.isExpanded();
		664	if (!expanded && actionPart != null && actionPart.getControl() instanceof ExpandableComposite) {
		665	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), true);
		666	if (!expanded) {
		667	CommonFormUtil.setExpanded((ExpandableComposite) actionPart.getControl(), false);
		668	}
669	}
670
671	EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), attribute.getId());
672	}
673	} else {
674	TaskRelation taskRelation = node.getTaskRelation();
675	TaskRepository taskRepository = node.getTaskRepository();
676	if (taskRelation != null && taskRepository != null) {
677	String taskID = taskRelation.getTaskId();
678	TasksUiUtil.openTask(taskRepository, taskID);
679	} else {
680	EditorUtil.reveal(taskEditorPage.getManagedForm().getForm(), node.getLabel());
681	}
682	}
683	}
684	}
593	}	685	}

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorOutlineContentProvider.java (+56 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 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.tasks.ui.editors;
13
14	import org.eclipse.jface.viewers.ITreeContentProvider;
15	import org.eclipse.jface.viewers.Viewer;
16
17	public class TaskEditorOutlineContentProvider implements ITreeContentProvider {
18
19	public void dispose() {
20	// ignore
21	}
22
23	public Object[] getChildren(Object parentElement) {
24	if (parentElement instanceof TaskEditorOutlineNode) {
25	Object[] children = ((TaskEditorOutlineNode) parentElement).getChildren();
26	return children;
27	}
28	return new Object[0];
29	}
30
31	public Object[] getElements(Object inputElement) {
32	if (inputElement instanceof TaskEditorOutlineModel) {
33	return new Object[] { ((TaskEditorOutlineModel) inputElement).getRoot() };
34	}
35	return new Object[0];
36	}
37
38	public Object getParent(Object element) {
39	if (element instanceof TaskEditorOutlineNode) {
40	return ((TaskEditorOutlineNode) element).getParent();
41	}
42	return null;
43	}
44
45	public boolean hasChildren(Object element) {
46	if (element instanceof TaskEditorOutlineNode) {
47	return ((TaskEditorOutlineNode) element).getChildren().length > 0;
48	}
49	return false;
50	}
51
52	public void inputChanged(Viewer viewerChanged, Object oldInput, Object newInput) {
53	// ignore
54	}
55
56	}

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorOutlineNodeLabelProvider.java (+116 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.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	/**
28	* @author Frank Becker
29	*/
30	public class TaskEditorOutlineNodeLabelProvider extends LabelProvider {
31
32	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
33
34	@Override
35	public Image getImage(Object element) {
36	if (element instanceof TaskEditorOutlineNode) {
37	TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
38	if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
39	\|\| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())) {
40	return CommonImages.getImage(TasksUiImages.COMMENT);
41	}
42	if (TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
43	return CommonImages.getImage(TasksUiImages.TASK_NOTES);
44	} else if (node.getTaskComment() != null) {
45	IRepositoryPerson author = node.getTaskComment().getAuthor();
46	TaskAttribute taskAttribute = node.getData();
47	String repositoryUrl = taskAttribute.getTaskData().getRepositoryUrl();
48	String connectorKind = null;
49	TaskRepository taskRepository = null;
50	if (repositoryUrl != null) {
51	connectorKind = taskAttribute.getTaskData().getConnectorKind();
52	if (connectorKind != null) {
53	taskRepository = TasksUi.getRepositoryManager().getRepository(connectorKind, repositoryUrl);
54	}
55	}
56	if (taskRepository != null && author != null
57	&& author.getPersonId().equals(taskRepository.getUserName())) {
58	return CommonImages.getImage(CommonImages.PERSON_ME);
59	} else {
60	return CommonImages.getImage(CommonImages.PERSON);
61	}
62	} else if (node.getTaskAttachment() != null) {
63	ITaskAttachment attachment = node.getTaskAttachment();
64	if (AttachmentUtil.isContext(attachment)) {
65	return CommonImages.getImage(TasksUiImages.CONTEXT_TRANSFER);
66	} else if (attachment.isPatch()) {
67	return CommonImages.getImage(TasksUiImages.TASK_ATTACHMENT_PATCH);
68	} else {
69	String filename = attachment.getFileName();
70	if (filename != null) {
71	int dotIndex = filename.lastIndexOf('.');
72	if (dotIndex != -1) {
73	String fileType = filename.substring(dotIndex + 1);
74	for (String element2 : IMAGE_EXTENSIONS) {
75	if (element2.equalsIgnoreCase(fileType)) {
76	return CommonImages.getImage(CommonImages.IMAGE_FILE);
77	}
78	}
79	}
80	}
81	return WorkbenchImages.getImage(ISharedImages.IMG_OBJ_FILE);
82	}
83	} else if (node.getData() != null) {
84	return super.getImage(element);
85	} else {
86	return CommonImages.getImage(TasksUiImages.TASK);
87	}
88	} else {
89	return super.getImage(element);
90	}
91	}
92
93	@Override
94	public String getText(Object element) {
95	if (element instanceof TaskEditorOutlineNode) {
96	TaskEditorOutlineNode node = (TaskEditorOutlineNode) element;
97	if (TaskEditorOutlineNode.LABEL_COMMENTS.equals(node.getLabel())
98	\|\| TaskEditorOutlineNode.LABEL_NEW_COMMENT.equals(node.getLabel())
99	\|\| TaskEditorOutlineNode.LABEL_DESCRIPTION.equals(node.getLabel())) {
100	return node.getLabel();
101	}
102	if (node.getData() != null && node.getTaskAttachment() == null && node.getTaskComment() == null) {
103	// regular attribute
104	TaskAttribute taskAttribute = node.getData();
105	String label = taskAttribute.getTaskData().getAttributeMapper().getLabel(taskAttribute);
106	if (!label.endsWith(":")) { //$NON-NLS-1$
107	label += ":"; //$NON-NLS-1$
108	}
109	return label + " " + taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute); //$NON-NLS-1$
110	}
111	return node.getLabel();
112	}
113	return super.getText(element);
114	}
115
116	}

Lines 92-98 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage.java (-36 / +15 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-1071 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	});
1066	}	1039	}
1067	if (getModel() != null) {	1040	if (getModel() != null) {
1068	TaskEditorOutlineNode node = TaskEditorOutlineNode.parse(getModel().getTaskData());	1041	TaskEditorOutlineNode node = TaskEditorOutlineNode.parse(getModel().getTaskData(), false);
1069	outlinePage.setInput(getTaskRepository(), node);	1042	outlinePage.setInput(getTaskRepository(), node);
1070	} else {	1043	} else {
1071	outlinePage.setInput(null, null);	1044	outlinePage.setInput(null, null);
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