Attachment #65721 for bug #153573

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




            targetId="org.eclipse.ui.DefaultTextEditor">
      </hyperlinkDetector>
   </extension>
        <extension
              point="org.eclipse.ui.workingSets">
           <workingSet
                 elementAdapterClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetElementAdapter"
                 id="org.eclipse.mylar.tasks.ui.workingSet"
                 name="Tasks"
                 pageClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetPage"
                 updaterClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetUpdater">
           </workingSet>
        </extension>
   
  
</plugin>

Lines 15-20 Link Here

(-)src/org/eclipse/mylar/internal/tasks/ui/views/TaskListContentProvider.java (-4 / +54 lines)
15	import java.util.List;	15	import java.util.List;
16	import java.util.Set;	16	import java.util.Set;
17		17
		18	import org.eclipse.core.runtime.IAdaptable;
		19	import org.eclipse.jface.util.IPropertyChangeListener;
		20	import org.eclipse.jface.util.PropertyChangeEvent;
18	import org.eclipse.jface.viewers.IStructuredContentProvider;	21	import org.eclipse.jface.viewers.IStructuredContentProvider;
19	import org.eclipse.jface.viewers.ITreeContentProvider;	22	import org.eclipse.jface.viewers.ITreeContentProvider;
20	import org.eclipse.jface.viewers.Viewer;	23	import org.eclipse.jface.viewers.Viewer;
Lines 27-32 Link Here
27	import org.eclipse.mylar.tasks.core.Task;	30	import org.eclipse.mylar.tasks.core.Task;
28	import org.eclipse.mylar.tasks.core.TaskArchive;	31	import org.eclipse.mylar.tasks.core.TaskArchive;
29	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	32	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
		33	import org.eclipse.ui.IWorkingSet;
		34	import org.eclipse.ui.IWorkingSetManager;
		35	import org.eclipse.ui.PlatformUI;
30		36
31	/**	37	/**
32	* Provides custom content for the task list, e.g. guaranteed visibility of some	38	* Provides custom content for the task list, e.g. guaranteed visibility of some
Lines 37-48 Link Here
37	*	43	*
38	* @author Mik Kersten	44	* @author Mik Kersten
39	*/	45	*/
40	public class TaskListContentProvider implements IStructuredContentProvider, ITreeContentProvider {	46	public class TaskListContentProvider implements IStructuredContentProvider, ITreeContentProvider, IPropertyChangeListener {
41		47
42	protected final TaskListView view;	48	protected final TaskListView view;
		49
		50	private final IWorkingSetManager workingSetManager;
		51
		52	private IWorkingSet currentWorkingSet;
43		53
44	public TaskListContentProvider(TaskListView view) {	54	public TaskListContentProvider(TaskListView view) {
45	this.view = view;	55	this.view = view;
		56
		57	this.workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
		58	this.workingSetManager.addPropertyChangeListener(this);
46	}	59	}
47		60
48	public void inputChanged(Viewer v, Object oldInput, Object newInput) {	61	public void inputChanged(Viewer v, Object oldInput, Object newInput) {
Lines 50-56 Link Here
50	}	63	}
51		64
52	public void dispose() {	65	public void dispose() {
53	// ignore	66	workingSetManager.removePropertyChangeListener(this);
54	}	67	}
55		68
56	public Object[] getElements(Object parent) {	69	public Object[] getElements(Object parent) {
Lines 118-128 Link Here
118	}	131	}
119	} else if (element instanceof AbstractRepositoryQuery) {	132	} else if (element instanceof AbstractRepositoryQuery) {
120	if (selectQuery((AbstractRepositoryQuery) element)) {	133	if (selectQuery((AbstractRepositoryQuery) element)) {
121	filteredRoots.add(element);	134	if(selectWorkingSet((AbstractRepositoryQuery) element)) {
		135	filteredRoots.add(element);
		136	}
122	}	137	}
123	} else if (element instanceof AbstractTaskContainer) {	138	} else if (element instanceof AbstractTaskContainer) {
124	if (selectContainer((AbstractTaskContainer) element)) {	139	if (selectContainer((AbstractTaskContainer) element)) {
125	filteredRoots.add(element);	140	if(selectWorkingSet((AbstractTaskContainer) element)) {
		141	filteredRoots.add(element);
		142	}
126	}	143	}
127	}	144	}
128	}	145	}
Lines 132-137 Link Here
132	}	149	}
133	}	150	}
134		151
		152	private boolean selectWorkingSet(AbstractTaskContainer container) {
		153	if(currentWorkingSet==null) {
		154	return true;
		155	}
		156	boolean seenTaskWorkingSets = false;
		157	for (IAdaptable adaptable : currentWorkingSet.getElements()) {
		158	if(adaptable instanceof AbstractTaskContainer) {
		159	seenTaskWorkingSets = true;
		160	if(container.getHandleIdentifier().equals(((AbstractTaskContainer) adaptable).getHandleIdentifier())) {
		161	return true;
		162	}
		163	}
		164	}
		165	return !seenTaskWorkingSets;
		166	}
		167
135	/**	168	/**
136	* See bug 109693	169	* See bug 109693
137	*/	170	*/
Lines 263-266 Link Here
263	return false;	296	return false;
264	}	297	}
265		298
		299
		300	// IPropertyChangeListener
		301
		302	public void propertyChange(PropertyChangeEvent event) {
		303	// System.err.println(event.getProperty() + " : " + event.getNewValue());
		304
		305	if(IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(event.getProperty())) {
		306	currentWorkingSet = (IWorkingSet) event.getNewValue();
		307	// for (IAdaptable adaptable : currentWorkingSet.getElements()) {
		308	// System.err.println(" " + adaptable);
		309	// }
		310	}
		311
		312	// System.err.println(Arrays.toString(currentWorkingSets));
		313	this.view.refreshAndFocus(true);
		314	}
		315
266	}	316	}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 Mylar committers 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
 *******************************************************************************/

package org.eclipse.mylar.internal.tasks.ui.workingset;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
import org.eclipse.mylar.tasks.core.ITaskListElement;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
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.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.IWorkingSetPage;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;

/**
 * Adapted from org.eclipse.ui.internal.ide.dialogs.ResourceWorkingSetPage
 */
public class TaskWorkingSetPage extends WizardPage implements IWorkingSetPage {

    private final static int SIZING_SELECTION_WIDGET_WIDTH = 50;

    private final static int SIZING_SELECTION_WIDGET_HEIGHT = 200;

    private Text text;

    private CheckboxTreeViewer tree;

    private IWorkingSet workingSet;

	private boolean firstCheck = false;

    
	public TaskWorkingSetPage() {
        super("taskWorkingSetPage", //$NON-NLS-1$ 
				"Task Working Set", null); // the icon
		setDescription("Enter a working set name and select task categories/queries.");
	}

	@SuppressWarnings("unchecked")
	public void finish() {
        // List<AbstractTaskContainer> elements = getCheckedElements((List<AbstractTaskContainer>) tree.getInput());
        Object[] elements = tree.getCheckedElements();
        IAdaptable[] adaptables = new IAdaptable[elements.length];
        for (int i = 0; i < adaptables.length; i++) {
        	adaptables[i] = (IAdaptable) elements[i];
		}
        
        if (workingSet == null) {
            IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
            workingSet = workingSetManager.createWorkingSet(getWorkingSetName(), adaptables);
        } else {
            workingSet.setName(getWorkingSetName());
			workingSet.setElements(adaptables);
        }
	}

	public IWorkingSet getSelection() {
		return workingSet;
	}

	public void setSelection(IWorkingSet workingSet) {
		this.workingSet = workingSet;
        if (getShell() != null && text != null) {
            firstCheck = true;
            initializeCheckedState();
            text.setText(workingSet.getName());
        }
	}
	
    private String getWorkingSetName() {
        return text.getText();
    }

	public void createControl(Composite parent) {
    	initializeDialogUnits(parent);
    	
        Composite composite = new Composite(parent, SWT.NULL);
        
        GridLayout layout = new GridLayout();
        layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
        layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
        layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
        composite.setLayout(layout);
        composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
        setControl(composite);

        // PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IIDEHelpContextIds.WORKING_SET_RESOURCE_PAGE);
        Label label = new Label(composite, SWT.WRAP);
        label.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_message);
        label.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
                | GridData.HORIZONTAL_ALIGN_FILL
                | GridData.VERTICAL_ALIGN_CENTER));

        text = new Text(composite, SWT.SINGLE | SWT.BORDER);
        text.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
                | GridData.HORIZONTAL_ALIGN_FILL));
        text.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                validateInput();
            }
        });
        text.setFocus();
        // text.setBackground(FieldAssistColors.getRequiredFieldBackgroundColor(text));

        label = new Label(composite, SWT.WRAP);
        label.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_label_tree);
        label.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
                | GridData.HORIZONTAL_ALIGN_FILL
                | GridData.VERTICAL_ALIGN_CENTER));

        tree = new CheckboxTreeViewer(composite);
        tree.setUseHashlookup(true);

        final ITreeContentProvider treeContentProvider = new ITreeContentProvider() {

    		@SuppressWarnings("unchecked")
			public Object[] getChildren(Object parentElement) {
				if(parentElement instanceof List) {
					List containers = (List) parentElement;
					return containers.toArray(new Object[containers.size()]);
				}
				return new Object[0];
			}

			@SuppressWarnings("unchecked")
			public boolean hasChildren(Object element) {
				return getChildren(element).length > 0;
			}
			
			public Object[] getElements(Object element) {
				return getChildren(element);
			}

			public Object getParent(Object element) {
				return null;
			}
			
			public void dispose() {
			}

			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		};

        tree.setContentProvider(treeContentProvider);

        // XXX get real label provider from the task list
        // tree.setLabelProvider(new TaskListLabelProvider());
        
		ArrayList<Object> containers = new ArrayList<Object>();
		for (ITaskListElement element : (Set<ITaskListElement>) TasksUiPlugin.getTaskListManager().getTaskList().getRootElements()) {
			if (element instanceof AbstractTaskContainer) {
				containers.add(element);
			}
		}
        tree.setInput(containers);
        
        // tree.setComparator(new ResourceComparator(ResourceComparator.NAME));

        GridData data = new GridData(GridData.FILL_BOTH | GridData.GRAB_VERTICAL);
        data.heightHint = SIZING_SELECTION_WIDGET_HEIGHT;
        data.widthHint = SIZING_SELECTION_WIDGET_WIDTH;
        tree.getControl().setLayoutData(data);

        tree.addCheckStateListener(new ICheckStateListener() {
            public void checkStateChanged(CheckStateChangedEvent event) {
                handleCheckStateChange(event);
            }
        });

//        tree.addTreeListener(new ITreeViewerListener() {
//            public void treeCollapsed(TreeExpansionEvent event) {
//            }
//
//            public void treeExpanded(TreeExpansionEvent event) {
//                final Object element = event.getElement();
//                if (tree.getGrayed(element) == false) {
//					BusyIndicator.showWhile(getShell().getDisplay(),
//                            new Runnable() {
//                                public void run() {
//                                    setSubtreeChecked((IContainer) element,
//                                            tree.getChecked(element), false);
//                                }
//                            });
//				}
//            }
//        });

		// Add select / deselect all buttons for bug 46669
		Composite buttonComposite = new Composite(composite, SWT.NONE);
		layout = new GridLayout(2, false);
		layout.marginWidth = 0;
		layout.marginHeight = 0;
		layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		buttonComposite.setLayout(layout);
		buttonComposite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
		
		Button selectAllButton = new Button(buttonComposite, SWT.PUSH);
		selectAllButton.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_selectAll_label);
		selectAllButton.setToolTipText(IDEWorkbenchMessages.ResourceWorkingSetPage_selectAll_toolTip);
		selectAllButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent selectionEvent) {
				tree.setCheckedElements(treeContentProvider.getElements(tree.getInput()));
				validateInput();
			}
		});
		setButtonLayoutData(selectAllButton);

		Button deselectAllButton = new Button(buttonComposite, SWT.PUSH);
		deselectAllButton.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_deselectAll_label);
		deselectAllButton.setToolTipText(IDEWorkbenchMessages.ResourceWorkingSetPage_deselectAll_toolTip);
		deselectAllButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent selectionEvent) {
				tree.setCheckedElements(new Object[0]);
				validateInput();
			}
		});
		setButtonLayoutData(deselectAllButton);
		
		initializeCheckedState();
        if (workingSet != null) {
            text.setText(workingSet.getName());
        }
        setPageComplete(false);
        
        Dialog.applyDialogFont(composite);
	}

	private void initializeCheckedState() {
        BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
			public void run() {
				Object[] items = null;
				if (workingSet != null) {
					items = workingSet.getElements();
					if (items != null) {
						tree.setCheckedElements(items);
					}
				}
			}
		});
	}

	protected void handleCheckStateChange(final CheckStateChangedEvent event) {
        BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
            public void run() {
            	AbstractTaskContainer element = (AbstractTaskContainer) event.getElement();
            	tree.setGrayed(element, false);

                // boolean state = event.getChecked();
                // if (element instanceof AbstractTaskContainer) {
                //     setSubtreeChecked((AbstractTaskContainer) element, state, true);
                // }
                // updateParentState(element);
                validateInput();
            }
        });
	}

	protected void validateInput() {
        String errorMessage = null;
        String infoMessage= null;
        String newText = text.getText();

        if (!newText.equals(newText.trim())) {
            errorMessage = "The name must not have a leading or trailing whitespace."; 
        } else if (firstCheck) {
            firstCheck = false;
            return;
        }
        if ("".equals(newText)) { //$NON-NLS-1$
            errorMessage = "The name must not be empty.";
        }
        if (errorMessage == null
                && (workingSet == null || !newText.equals(workingSet.getName()))) {
            IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
            for (int i = 0; i < workingSets.length; i++) {
                if (newText.equals(workingSets[i].getName())) {
                    errorMessage = "A working set with the same name already exists.";
                }
            }
        }
        if (infoMessage == null && tree.getCheckedElements().length == 0) {
        	infoMessage = "No categories/queries selected.";
        }
        setMessage(infoMessage, INFORMATION);
        setErrorMessage(errorMessage);
        setPageComplete(errorMessage == null);
	}
	
}





/*******************************************************************************
 * Copyright (c) 2004 - 2006 Mylar committers 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
 *******************************************************************************/

package org.eclipse.mylar.internal.tasks.ui.workingset;

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

import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.ITaskListChangeListener;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetUpdater;

public class TaskWorkingSetUpdater implements IWorkingSetUpdater, ITaskListChangeListener {

	private List<IWorkingSet> workingSets = new ArrayList<IWorkingSet>();

	
	public TaskWorkingSetUpdater() {
		TasksUiPlugin.getTaskListManager().getTaskList().addChangeListener(this);
	}
	
	// IWorkingSetUpdater
	
	public void add(IWorkingSet workingSet) {
		// checkElementExistence(workingSet);
		synchronized (workingSets) {
			workingSets.add(workingSet);
		}
	}

	public boolean contains(IWorkingSet workingSet) {
		synchronized(workingSets) {
			return workingSets.contains(workingSet);
		}
	}

	public boolean remove(IWorkingSet workingSet) {
		synchronized(workingSets) {
			return workingSets.remove(workingSet);
		}
	}

	public void dispose() {
		TasksUiPlugin.getTaskListManager().getTaskList().removeChangeListener(this);
	}

	
	// ITaskListChangeListener
	
	public void containerAdded(AbstractTaskContainer container) {
	}

	public void containerDeleted(AbstractTaskContainer container) {
		// XXX remove container from working set
	}

	public void containerInfoChanged(AbstractTaskContainer container) {
		// XXX need to do anything?
	}

	public void localInfoChanged(ITask task) {
	}

	public void repositoryInfoChanged(ITask task) {
	}

	public void taskAdded(ITask task) {
	}

	public void taskDeleted(ITask task) {
	}

	public void taskMoved(ITask task, AbstractTaskContainer fromContainer, AbstractTaskContainer toContainer) {
	}
	
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 Mylar committers 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
 *******************************************************************************/

package org.eclipse.mylar.internal.tasks.ui.workingset;

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

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetElementAdapter;

public class TaskWorkingSetElementAdapter implements IWorkingSetElementAdapter {

	public IAdaptable[] adaptElements(IWorkingSet ws, IAdaptable[] elements) {
		for (int i = 0; i < elements.length; i++) {
			IAdaptable adaptable = elements[i];
			if (!(adaptable instanceof AbstractTaskContainer)) {
				return selectContainers(elements);
			}
		}
		return elements;
	}
	
	private IAdaptable[] selectContainers(IAdaptable[] elements) {
		List<IAdaptable> containers = new ArrayList<IAdaptable>(elements.length);
		for (IAdaptable adaptable : elements) {
			if (adaptable instanceof AbstractTaskContainer) {
				containers.add(adaptable);
			}
		}
		return (IAdaptable[]) containers.toArray(new IAdaptable[containers.size()]);
	}

	public void dispose() {
	}

}

Return to bug 153573

Lines 773-778 Link Here

(-)plugin.xml (+10 lines)
773	targetId="org.eclipse.ui.DefaultTextEditor">	773	targetId="org.eclipse.ui.DefaultTextEditor">
774	</hyperlinkDetector>	774	</hyperlinkDetector>
775	</extension>	775	</extension>
		776	<extension
		777	point="org.eclipse.ui.workingSets">
		778	<workingSet
		779	elementAdapterClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetElementAdapter"
		780	id="org.eclipse.mylar.tasks.ui.workingSet"
		781	name="Tasks"
		782	pageClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetPage"
		783	updaterClass="org.eclipse.mylar.internal.tasks.ui.workingset.TaskWorkingSetUpdater">
		784	</workingSet>
		785	</extension>
776		786
777		787
778	</plugin>	788	</plugin>

Added Link Here

(-)src/org/eclipse/mylar/internal/tasks/ui/workingset/TaskWorkingSetPage.java (+321 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 Mylar committers 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
9	package org.eclipse.mylar.internal.tasks.ui.workingset;
10
11	import java.util.ArrayList;
12	import java.util.List;
13	import java.util.Set;
14
15	import org.eclipse.core.runtime.IAdaptable;
16	import org.eclipse.jface.dialogs.Dialog;
17	import org.eclipse.jface.dialogs.IDialogConstants;
18	import org.eclipse.jface.viewers.CheckStateChangedEvent;
19	import org.eclipse.jface.viewers.CheckboxTreeViewer;
20	import org.eclipse.jface.viewers.ICheckStateListener;
21	import org.eclipse.jface.viewers.ITreeContentProvider;
22	import org.eclipse.jface.viewers.Viewer;
23	import org.eclipse.jface.wizard.WizardPage;
24	import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
25	import org.eclipse.mylar.tasks.core.ITaskListElement;
26	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
27	import org.eclipse.swt.SWT;
28	import org.eclipse.swt.custom.BusyIndicator;
29	import org.eclipse.swt.events.ModifyEvent;
30	import org.eclipse.swt.events.ModifyListener;
31	import org.eclipse.swt.events.SelectionAdapter;
32	import org.eclipse.swt.events.SelectionEvent;
33	import org.eclipse.swt.layout.GridData;
34	import org.eclipse.swt.layout.GridLayout;
35	import org.eclipse.swt.widgets.Button;
36	import org.eclipse.swt.widgets.Composite;
37	import org.eclipse.swt.widgets.Label;
38	import org.eclipse.swt.widgets.Text;
39	import org.eclipse.ui.IWorkingSet;
40	import org.eclipse.ui.IWorkingSetManager;
41	import org.eclipse.ui.PlatformUI;
42	import org.eclipse.ui.dialogs.IWorkingSetPage;
43	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
44
45	/**
46	* Adapted from org.eclipse.ui.internal.ide.dialogs.ResourceWorkingSetPage
47	*/
48	public class TaskWorkingSetPage extends WizardPage implements IWorkingSetPage {
49
50	private final static int SIZING_SELECTION_WIDGET_WIDTH = 50;
51
52	private final static int SIZING_SELECTION_WIDGET_HEIGHT = 200;
53
54	private Text text;
55
56	private CheckboxTreeViewer tree;
57
58	private IWorkingSet workingSet;
59
60	private boolean firstCheck = false;
61
62
63	public TaskWorkingSetPage() {
64	super("taskWorkingSetPage", //$NON-NLS-1$
65	"Task Working Set", null); // the icon
66	setDescription("Enter a working set name and select task categories/queries.");
67	}
68
69	@SuppressWarnings("unchecked")
70	public void finish() {
71	// List<AbstractTaskContainer> elements = getCheckedElements((List<AbstractTaskContainer>) tree.getInput());
72	Object[] elements = tree.getCheckedElements();
73	IAdaptable[] adaptables = new IAdaptable[elements.length];
74	for (int i = 0; i < adaptables.length; i++) {
75	adaptables[i] = (IAdaptable) elements[i];
76	}
77
78	if (workingSet == null) {
79	IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
80	workingSet = workingSetManager.createWorkingSet(getWorkingSetName(), adaptables);
81	} else {
82	workingSet.setName(getWorkingSetName());
83	workingSet.setElements(adaptables);
84	}
85	}
86
87	public IWorkingSet getSelection() {
88	return workingSet;
89	}
90
91	public void setSelection(IWorkingSet workingSet) {
92	this.workingSet = workingSet;
93	if (getShell() != null && text != null) {
94	firstCheck = true;
95	initializeCheckedState();
96	text.setText(workingSet.getName());
97	}
98	}
99
100	private String getWorkingSetName() {
101	return text.getText();
102	}
103
104	public void createControl(Composite parent) {
105	initializeDialogUnits(parent);
106
107	Composite composite = new Composite(parent, SWT.NULL);
108
109	GridLayout layout = new GridLayout();
110	layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
111	layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
112	layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
113	composite.setLayout(layout);
114	composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
115	setControl(composite);
116
117	// PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IIDEHelpContextIds.WORKING_SET_RESOURCE_PAGE);
118	Label label = new Label(composite, SWT.WRAP);
119	label.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_message);
120	label.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
121	\| GridData.HORIZONTAL_ALIGN_FILL
122	\| GridData.VERTICAL_ALIGN_CENTER));
123
124	text = new Text(composite, SWT.SINGLE \| SWT.BORDER);
125	text.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
126	\| GridData.HORIZONTAL_ALIGN_FILL));
127	text.addModifyListener(new ModifyListener() {
128	public void modifyText(ModifyEvent e) {
129	validateInput();
130	}
131	});
132	text.setFocus();
133	// text.setBackground(FieldAssistColors.getRequiredFieldBackgroundColor(text));
134
135	label = new Label(composite, SWT.WRAP);
136	label.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_label_tree);
137	label.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
138	\| GridData.HORIZONTAL_ALIGN_FILL
139	\| GridData.VERTICAL_ALIGN_CENTER));
140
141	tree = new CheckboxTreeViewer(composite);
142	tree.setUseHashlookup(true);
143
144	final ITreeContentProvider treeContentProvider = new ITreeContentProvider() {
145
146	@SuppressWarnings("unchecked")
147	public Object[] getChildren(Object parentElement) {
148	if(parentElement instanceof List) {
149	List containers = (List) parentElement;
150	return containers.toArray(new Object[containers.size()]);
151	}
152	return new Object[0];
153	}
154
155	@SuppressWarnings("unchecked")
156	public boolean hasChildren(Object element) {
157	return getChildren(element).length > 0;
158	}
159
160	public Object[] getElements(Object element) {
161	return getChildren(element);
162	}
163
164	public Object getParent(Object element) {
165	return null;
166	}
167
168	public void dispose() {
169	}
170
171	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
172	}
173	};
174
175	tree.setContentProvider(treeContentProvider);
176
177	// XXX get real label provider from the task list
178	// tree.setLabelProvider(new TaskListLabelProvider());
179
180	ArrayList<Object> containers = new ArrayList<Object>();
181	for (ITaskListElement element : (Set<ITaskListElement>) TasksUiPlugin.getTaskListManager().getTaskList().getRootElements()) {
182	if (element instanceof AbstractTaskContainer) {
183	containers.add(element);
184	}
185	}
186	tree.setInput(containers);
187
188	// tree.setComparator(new ResourceComparator(ResourceComparator.NAME));
189
190	GridData data = new GridData(GridData.FILL_BOTH \| GridData.GRAB_VERTICAL);
191	data.heightHint = SIZING_SELECTION_WIDGET_HEIGHT;
192	data.widthHint = SIZING_SELECTION_WIDGET_WIDTH;
193	tree.getControl().setLayoutData(data);
194
195	tree.addCheckStateListener(new ICheckStateListener() {
196	public void checkStateChanged(CheckStateChangedEvent event) {
197	handleCheckStateChange(event);
198	}
199	});
200
201	// tree.addTreeListener(new ITreeViewerListener() {
202	// public void treeCollapsed(TreeExpansionEvent event) {
203	// }
204	//
205	// public void treeExpanded(TreeExpansionEvent event) {
206	// final Object element = event.getElement();
207	// if (tree.getGrayed(element) == false) {
208	// BusyIndicator.showWhile(getShell().getDisplay(),
209	// new Runnable() {
210	// public void run() {
211	// setSubtreeChecked((IContainer) element,
212	// tree.getChecked(element), false);
213	// }
214	// });
215	// }
216	// }
217	// });
218
219	// Add select / deselect all buttons for bug 46669
220	Composite buttonComposite = new Composite(composite, SWT.NONE);
221	layout = new GridLayout(2, false);
222	layout.marginWidth = 0;
223	layout.marginHeight = 0;
224	layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
225	buttonComposite.setLayout(layout);
226	buttonComposite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
227
228	Button selectAllButton = new Button(buttonComposite, SWT.PUSH);
229	selectAllButton.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_selectAll_label);
230	selectAllButton.setToolTipText(IDEWorkbenchMessages.ResourceWorkingSetPage_selectAll_toolTip);
231	selectAllButton.addSelectionListener(new SelectionAdapter() {
232	public void widgetSelected(SelectionEvent selectionEvent) {
233	tree.setCheckedElements(treeContentProvider.getElements(tree.getInput()));
234	validateInput();
235	}
236	});
237	setButtonLayoutData(selectAllButton);
238
239	Button deselectAllButton = new Button(buttonComposite, SWT.PUSH);
240	deselectAllButton.setText(IDEWorkbenchMessages.ResourceWorkingSetPage_deselectAll_label);
241	deselectAllButton.setToolTipText(IDEWorkbenchMessages.ResourceWorkingSetPage_deselectAll_toolTip);
242	deselectAllButton.addSelectionListener(new SelectionAdapter() {
243	public void widgetSelected(SelectionEvent selectionEvent) {
244	tree.setCheckedElements(new Object[0]);
245	validateInput();
246	}
247	});
248	setButtonLayoutData(deselectAllButton);
249
250	initializeCheckedState();
251	if (workingSet != null) {
252	text.setText(workingSet.getName());
253	}
254	setPageComplete(false);
255
256	Dialog.applyDialogFont(composite);
257	}
258
259	private void initializeCheckedState() {
260	BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
261	public void run() {
262	Object[] items = null;
263	if (workingSet != null) {
264	items = workingSet.getElements();
265	if (items != null) {
266	tree.setCheckedElements(items);
267	}
268	}
269	}
270	});
271	}
272
273	protected void handleCheckStateChange(final CheckStateChangedEvent event) {
274	BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
275	public void run() {
276	AbstractTaskContainer element = (AbstractTaskContainer) event.getElement();
277	tree.setGrayed(element, false);
278
279	// boolean state = event.getChecked();
280	// if (element instanceof AbstractTaskContainer) {
281	// setSubtreeChecked((AbstractTaskContainer) element, state, true);
282	// }
283	// updateParentState(element);
284	validateInput();
285	}
286	});
287	}
288
289	protected void validateInput() {
290	String errorMessage = null;
291	String infoMessage= null;
292	String newText = text.getText();
293
294	if (!newText.equals(newText.trim())) {
295	errorMessage = "The name must not have a leading or trailing whitespace.";
296	} else if (firstCheck) {
297	firstCheck = false;
298	return;
299	}
300	if ("".equals(newText)) { //$NON-NLS-1$
301	errorMessage = "The name must not be empty.";
302	}
303	if (errorMessage == null
304	&& (workingSet == null \|\| !newText.equals(workingSet.getName()))) {
305	IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
306	for (int i = 0; i < workingSets.length; i++) {
307	if (newText.equals(workingSets[i].getName())) {
308	errorMessage = "A working set with the same name already exists.";
309	}
310	}
311	}
312	if (infoMessage == null && tree.getCheckedElements().length == 0) {
313	infoMessage = "No categories/queries selected.";
314	}
315	setMessage(infoMessage, INFORMATION);
316	setErrorMessage(errorMessage);
317	setPageComplete(errorMessage == null);
318	}
319
320	}
321