Attachment #39758 for bug #129086

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

Lines 21-28 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraRepositoryConnector.java (-23 / +74 lines)
21	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
22	import org.eclipse.core.runtime.MultiStatus;	22	import org.eclipse.core.runtime.MultiStatus;
23	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
		24	import org.eclipse.jface.window.Window;
24	import org.eclipse.jface.wizard.IWizard;	25	import org.eclipse.jface.wizard.IWizard;
		26	import org.eclipse.jface.wizard.WizardDialog;
		27	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
25	import org.eclipse.mylar.internal.jira.ui.wizards.AddExistingJiraTaskWizard;	28	import org.eclipse.mylar.internal.jira.ui.wizards.AddExistingJiraTaskWizard;
		29	import org.eclipse.mylar.internal.jira.ui.wizards.EditJiraQueryWizard;
26	import org.eclipse.mylar.internal.jira.ui.wizards.JiraRepositorySettingsPage;	30	import org.eclipse.mylar.internal.jira.ui.wizards.JiraRepositorySettingsPage;
27	import org.eclipse.mylar.internal.jira.ui.wizards.NewJiraQueryWizard;	31	import org.eclipse.mylar.internal.jira.ui.wizards.NewJiraQueryWizard;
28	import org.eclipse.mylar.internal.tasklist.ui.TaskUiUtil;	32	import org.eclipse.mylar.internal.tasklist.ui.TaskUiUtil;
Lines 35-42 Link Here
35	import org.eclipse.mylar.provisional.tasklist.ITask;	39	import org.eclipse.mylar.provisional.tasklist.ITask;
36	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;	40	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
37	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	41	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
		42	import org.eclipse.swt.widgets.Shell;
		43	import org.eclipse.ui.PlatformUI;
38	import org.tigris.jira.core.model.Issue;	44	import org.tigris.jira.core.model.Issue;
39	import org.tigris.jira.core.model.filter.IssueCollector;	45	import org.tigris.jira.core.model.filter.IssueCollector;
		46	import org.tigris.jira.core.service.JiraServer;
40		47
41	/**	48	/**
42	* @author Mik Kersten	49	* @author Mik Kersten
Lines 56-68 Link Here
56		63
57	private final IProgressMonitor monitor;	64	private final IProgressMonitor monitor;
58		65
59	private final JiraRepositoryQuery query;	66	private final AbstractRepositoryQuery query;
60		67
61	private final List<AbstractQueryHit> hits;	68	private final List<AbstractQueryHit> hits;
62		69
63	private boolean done = false;	70	private boolean done = false;
64		71
65	private JiraIssueCollector(IProgressMonitor monitor, JiraRepositoryQuery query, List<AbstractQueryHit> hits) {	72	JiraIssueCollector(IProgressMonitor monitor, AbstractRepositoryQuery query, List<AbstractQueryHit> hits) {
66	this.monitor = monitor;	73	this.monitor = monitor;
67	this.query = query;	74	this.query = query;
68	this.hits = hits;	75	this.hits = hits;
Lines 135-165 Link Here
135	return new AddExistingJiraTaskWizard(repository);	142	return new AddExistingJiraTaskWizard(repository);
136	}	143	}
137		144
		145
		146
138	@Override	147	@Override
139	public void openEditQueryDialog(AbstractRepositoryQuery query) {	148	public void openEditQueryDialog(AbstractRepositoryQuery query) {
140	JiraRepositoryQuery filter = (JiraRepositoryQuery) query;	149	// JiraRepositoryQuery filter = (JiraRepositoryQuery) query;
141	String title = "Filter: " + filter.getDescription();	150	// String title = "Filter: " + filter.getDescription();
142	TaskUiUtil.openUrl(title, title, filter.getQueryUrl());	151	// TaskUiUtil.openUrl(title, title, filter.getQueryUrl());
		152
		153	// if (query instanceof JiraRepositoryQuery) {
		154	// JiraRepositoryQuery filter = (JiraRepositoryQuery) query;
		155	// String title = "Filter: " + filter.getDescription();
		156	// TaskUiUtil.openUrl(title, title, filter.getQueryUrl());
		157	// } else if(query instanceof JiraCustomQuery) {
		158	// // new JiraQueryWizardPage();
		159	// }
		160
		161	try {
		162	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(
		163	query.getRepositoryKind(), query.getRepositoryUrl());
		164	if (repository == null)
		165	return;
		166
		167	IWizard wizard = this.getEditQueryWizard(repository, query);
		168
		169	Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		170	if (wizard != null && shell != null && !shell.isDisposed()) {
		171	WizardDialog dialog = new WizardDialog(shell, wizard);
		172	dialog.create();
		173	dialog.setTitle("Edit Jira Query");
		174	dialog.setBlockOnOpen(true);
		175	if (dialog.open() == Window.CANCEL) {
		176	dialog.close();
		177	return;
		178	}
		179	}
		180	} catch (Exception e) {
		181	MylarStatusHandler.fail(e, e.getMessage(), true);
		182	}
		183
		184	}
		185
		186	private IWizard getEditQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {
		187	if (query instanceof JiraRepositoryQuery \|\| query instanceof JiraCustomQuery) {
		188	return new EditJiraQueryWizard(repository, query);
		189	}
		190	return null;
143	}	191	}
144		192
145	@Override	193	@Override
146	protected List<AbstractQueryHit> performQuery(AbstractRepositoryQuery repositoryQuery,	194	protected List<AbstractQueryHit> performQuery(AbstractRepositoryQuery repositoryQuery,
147	final IProgressMonitor monitor, MultiStatus queryStatus) {	195	final IProgressMonitor monitor, MultiStatus queryStatus) {
148	if (!(repositoryQuery instanceof JiraRepositoryQuery)) {
149	return Collections.emptyList();
150	}
151	final JiraRepositoryQuery jiraRepositoryQuery = (JiraRepositoryQuery) repositoryQuery;
152	final List<AbstractQueryHit> hits = new ArrayList<AbstractQueryHit>();	196	final List<AbstractQueryHit> hits = new ArrayList<AbstractQueryHit>();
153	JiraIssueCollector collector = new JiraIssueCollector(monitor, jiraRepositoryQuery, hits);
154	try {
155	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(
156	MylarJiraPlugin.REPOSITORY_KIND, repositoryQuery.getRepositoryUrl());
157	JiraServerFacade.getDefault().getJiraServer(repository).search(jiraRepositoryQuery.getNamedFilter(), collector);
158		197
		198	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(
		199	MylarJiraPlugin.REPOSITORY_KIND, repositoryQuery.getRepositoryUrl());
		200
		201	JiraIssueCollector collector = new JiraIssueCollector(monitor, repositoryQuery, hits);
		202
		203	try {
		204	JiraServer jiraServer = JiraServerFacade.getDefault().getJiraServer(repository);
		205
		206	if (repositoryQuery instanceof JiraRepositoryQuery) {
		207	jiraServer.search(((JiraRepositoryQuery) repositoryQuery).getNamedFilter(), collector);
		208
		209	} else if (repositoryQuery instanceof JiraCustomQuery) {
		210	jiraServer.search(((JiraCustomQuery) repositoryQuery).getFilterDefinition(), collector);
		211	}
159	} catch (Exception e) {	212	} catch (Exception e) {
160	queryStatus.add(new Status(IStatus.OK, MylarTaskListPlugin.PLUGIN_ID, IStatus.OK,	213	queryStatus.add(new Status(IStatus.OK, MylarTaskListPlugin.PLUGIN_ID, IStatus.OK,
161	"Could not log in to server: " + repositoryQuery.getRepositoryUrl()	214	"Could not log in to server: " + repositoryQuery.getRepositoryUrl()
162	+ "\n\nCheck network connection.", e));	215	+ "\n\nCheck network connection.", e));
163	}	216	}
164	queryStatus.add(Status.OK_STATUS);	217	queryStatus.add(Status.OK_STATUS);
165	return hits;	218	return hits;
Lines 219-231 Link Here
219	public String getRepositoryUrlFromTaskUrl(String url) {	272	public String getRepositoryUrlFromTaskUrl(String url) {
220	if (url == null) {	273	if (url == null) {
221	return null;	274	return null;
222	} else {
223	int index = url.indexOf(DELIM_URL);
224	if (index != -1) {
225	return url.substring(0, index);
226	} else {
227	return null;
228	}
229	}	275	}
		276	int index = url.indexOf(DELIM_URL);
		277	if (index != -1) {
		278	return url.substring(0, index);
		279	}
		280	return null;
230	}	281	}
231	}	282	}

Lines 11-16 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java (-15 / +88 lines)
11		11
12	package org.eclipse.mylar.internal.jira;	12	package org.eclipse.mylar.internal.jira;
13		13
		14	import java.io.ByteArrayInputStream;
		15	import java.io.ByteArrayOutputStream;
		16	import java.io.IOException;
		17	import java.io.ObjectInputStream;
		18	import java.io.ObjectOutputStream;
		19	import java.io.StringWriter;
		20
14	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	21	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
15	import org.eclipse.mylar.internal.tasklist.TaskExternalizationException;	22	import org.eclipse.mylar.internal.tasklist.TaskExternalizationException;
16	import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;	23	import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
Lines 24-29 Link Here
24	import org.eclipse.mylar.provisional.tasklist.TaskList;	31	import org.eclipse.mylar.provisional.tasklist.TaskList;
25	import org.tigris.jira.core.model.Issue;	32	import org.tigris.jira.core.model.Issue;
26	import org.tigris.jira.core.model.NamedFilter;	33	import org.tigris.jira.core.model.NamedFilter;
		34	import org.tigris.jira.core.model.filter.FilterDefinition;
27	import org.w3c.dom.Document;	35	import org.w3c.dom.Document;
28	import org.w3c.dom.Element;	36	import org.w3c.dom.Element;
29	import org.w3c.dom.Node;	37	import org.w3c.dom.Node;
Lines 38-49 Link Here
38	private static final String KEY_ISSUE_SUMMARY = "IssueSummary";	46	private static final String KEY_ISSUE_SUMMARY = "IssueSummary";
39		47
40	private static final String KEY_JIRA = "Jira";	48	private static final String KEY_JIRA = "Jira";
		49	private static final String KEY_CUSTOM = "JiraCustom";
41		50
42	private static final String KEY_JIRA_CATEGORY = "JiraQuery" + KEY_CATEGORY;	51	private static final String KEY_JIRA_CATEGORY = "JiraQuery" + KEY_CATEGORY;
43		52
44	private static final String KEY_JIRA_QUERY_HIT = KEY_JIRA + KEY_QUERY_HIT;	53	private static final String KEY_JIRA_QUERY_HIT = KEY_JIRA + KEY_QUERY_HIT;
45		54
46	private static final String KEY_JIRA_QUERY = KEY_JIRA + KEY_QUERY;	55	private static final String KEY_JIRA_QUERY = KEY_JIRA + KEY_QUERY;
		56	private static final String KEY_JIRA_CUSTOM = KEY_JIRA + KEY_CUSTOM + KEY_QUERY;
47		57
48	private static final String KEY_JIRA_ISSUE = "JiraIssue";	58	private static final String KEY_JIRA_ISSUE = "JiraIssue";
49		59
Lines 53-64 Link Here
53		63
54	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";	64	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
55		65
		66	private static final String KEY_FILTER_CUSTOM = "FilterCustom";
		67
		68
56	public boolean canReadQuery(Node node) {	69	public boolean canReadQuery(Node node) {
57	return node.getNodeName().equals(KEY_JIRA_QUERY);	70	return node.getNodeName().equals(KEY_JIRA_QUERY)
		71	\|\| node.getNodeName().equals(KEY_JIRA_CUSTOM);
58	}	72	}
59		73
60	public boolean canCreateElementFor(AbstractRepositoryQuery category) {	74	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
61	return category instanceof JiraRepositoryQuery;	75	return category instanceof JiraRepositoryQuery
		76	\|\| category instanceof JiraCustomQuery;
62	}	77	}
63		78
64	public boolean canCreateElementFor(ITask task) {	79	public boolean canCreateElementFor(ITask task) {
Lines 69-80 Link Here
69	boolean hasCaughtException = false;	84	boolean hasCaughtException = false;
70	Element element = (Element) node;	85	Element element = (Element) node;
71		86
72	NamedFilter namedFilter = new NamedFilter();	87	AbstractRepositoryQuery query;
73	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));	88	String custom = element.getAttribute(KEY_FILTER_CUSTOM);
74	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));	89	if(custom!=null) {
75	// namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));	90	FilterDefinition filter = decodeFilter(custom);
76		91	filter.setName(element.getAttribute(KEY_FILTER_ID));
77	AbstractRepositoryQuery query = new JiraRepositoryQuery(element.getAttribute(KEY_REPOSITORY_URL), namedFilter, MylarTaskListPlugin.getTaskListManager().getTaskList());	92	filter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
		93
		94	query = new JiraCustomQuery(element.getAttribute(KEY_REPOSITORY_URL), filter, MylarTaskListPlugin.getTaskListManager().getTaskList());
		95	} else {
		96	NamedFilter namedFilter = new NamedFilter();
		97	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));
		98	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));
		99	namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
		100
		101	query = new JiraRepositoryQuery(element.getAttribute(KEY_REPOSITORY_URL), namedFilter, MylarTaskListPlugin.getTaskListManager().getTaskList());
		102	}
78		103
79	NodeList list = node.getChildNodes();	104	NodeList list = node.getChildNodes();
80	for (int i = 0; i < list.getLength(); i++) {	105	for (int i = 0; i < list.getLength(); i++) {
Lines 87-111 Link Here
87	}	112	}
88	if (hasCaughtException) {	113	if (hasCaughtException) {
89	throw new TaskExternalizationException("Failed to load all hits");	114	throw new TaskExternalizationException("Failed to load all hits");
90	} else {
91	return query;
92	}	115	}
		116	return query;
93	}	117	}
94		118
95	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {	119	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {
96	String queryTagName = getQueryTagNameForElement(query);	120	String queryTagName = getQueryTagNameForElement(query);
97	Element node = doc.createElement(queryTagName);	121	Element node = doc.createElement(queryTagName);
98		122
99	NamedFilter filter = ((JiraRepositoryQuery) query).getNamedFilter();
100	node.setAttribute(KEY_NAME, query.getDescription());	123	node.setAttribute(KEY_NAME, query.getDescription());
101	node.setAttribute(KEY_QUERY_MAX_HITS, query.getMaxHits() + "");	124	node.setAttribute(KEY_QUERY_MAX_HITS, query.getMaxHits() + "");
102	node.setAttribute(KEY_QUERY_STRING, query.getQueryUrl());	125	node.setAttribute(KEY_QUERY_STRING, query.getQueryUrl());
103	node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());	126	node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());
104		127
105	node.setAttribute(KEY_FILTER_ID, filter.getId());	128	if (query instanceof JiraRepositoryQuery) {
106	node.setAttribute(KEY_FILTER_NAME, filter.getName());	129	NamedFilter filter = ((JiraRepositoryQuery) query).getNamedFilter();
107	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());	130	node.setAttribute(KEY_FILTER_ID, filter.getId());
108		131	node.setAttribute(KEY_FILTER_NAME, filter.getName());
		132	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
		133	} else {
		134	FilterDefinition filter = ((JiraCustomQuery) query).getFilterDefinition();
		135	node.setAttribute(KEY_FILTER_ID, filter.getName());
		136	node.setAttribute(KEY_FILTER_NAME, filter.getName());
		137	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
		138
		139	// XXX implement actual export
		140	node.setAttribute(KEY_FILTER_CUSTOM, encodeFilter(filter));
		141	}
		142
109	for (AbstractQueryHit hit : query.getHits()) {	143	for (AbstractQueryHit hit : query.getHits()) {
110	try {	144	try {
111	Element element = null;	145	Element element = null;
Lines 123-128 Link Here
123	return node;	157	return node;
124	}	158	}
125		159
		160	private String encodeFilter(FilterDefinition filter) {
		161	ByteArrayOutputStream bos = new ByteArrayOutputStream();
		162	ObjectOutputStream oos;
		163	try {
		164	oos = new ObjectOutputStream(bos);
		165	oos.writeObject(filter);
		166	oos.flush();
		167	} catch (IOException ex) {
		168	return null;
		169	}
		170
		171	StringWriter sw = new StringWriter();
		172	byte[] bytes = bos.toByteArray();
		173	for (int i = 0; i < bytes.length; i++) {
		174	byte b = bytes[i];
		175	sw.append((char) ('A' + (b >> 4))).append((char) ('A'+ (b & 0xf)));
		176	}
		177	return sw.toString();
		178	}
		179
		180	private FilterDefinition decodeFilter(String filter) {
		181	byte[] buff = new byte[filter.length()/2];
		182	char[] chars = filter.toCharArray();
		183	for (int i = 0, k = 0; i < chars.length; i += 2, k++) {
		184	buff[k] = (byte) ((((chars[i] - 'A') << 4) \| (chars[i+1] - 'A')) & 0xff);
		185	}
		186
		187	ObjectInputStream ois;
		188	try {
		189	ois = new ObjectInputStream(new ByteArrayInputStream(buff));
		190	return (FilterDefinition) ois.readObject();
		191	} catch (Exception ex) {
		192	// TODO Auto-generated catch block
		193	return null;
		194	}
		195	}
		196
126	@Override	197	@Override
127	public String getTaskTagName() {	198	public String getTaskTagName() {
128	return KEY_JIRA_ISSUE;	199	return KEY_JIRA_ISSUE;
Lines 226-231 Link Here
226	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {	297	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
227	if (query instanceof JiraRepositoryQuery) {	298	if (query instanceof JiraRepositoryQuery) {
228	return KEY_JIRA_QUERY;	299	return KEY_JIRA_QUERY;
		300	} else if( query instanceof JiraCustomQuery) {
		301	return KEY_JIRA_CUSTOM;
229	}	302	}
230	return "";	303	return "";
231	}	304	}




package org.eclipse.mylar.internal.jira.ui.wizards;

import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylar.internal.jira.JiraRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.tigris.jira.core.model.NamedFilter;

/**
 * Wizard that allows the user to select one of their named Jira filters on the

 * 
 * @author Mik Kersten
 * @author Wesley Coelho (initial integration patch)
 * @author Eugene Kuleshov (integration with editor pages)
 */
public class NewJiraQueryWizard extends Wizard {


	@Override
	public void addPages() {
		queryPage = new JiraQueryWizardPage(repository);
		queryPage.setWizard(this);
		addPage(queryPage);
	}

	@Override
	public boolean performFinish() {

		AbstractRepositoryQuery query = queryPage.getQuery();
		if (query != null) {
			MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(query);
			JiraRepositoryQuery filter = new JiraRepositoryQuery(repository.getUrl(), namedFilter, MylarTaskListPlugin.getTaskListManager().getTaskList());
			MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(filter);
			AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
			if (connector != null) {
				connector.synchronize(query, null);
			}
//			filter.refreshHits();
		} 

		return true;
	}

	
	
	public boolean canFinish() {
		if(queryPage.getNextPage() == null) {
			return queryPage.isPageComplete();
		}
		return queryPage.getNextPage().isPageComplete();
	}
	
}

Lines 16-23 Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryWizardPage.java (-25 / +109 lines)
16	import org.eclipse.core.runtime.Status;	16	import org.eclipse.core.runtime.Status;
17	import org.eclipse.core.runtime.jobs.Job;	17	import org.eclipse.core.runtime.jobs.Job;
18	import org.eclipse.jface.dialogs.MessageDialog;	18	import org.eclipse.jface.dialogs.MessageDialog;
		19	import org.eclipse.jface.wizard.IWizardPage;
19	import org.eclipse.jface.wizard.WizardPage;	20	import org.eclipse.jface.wizard.WizardPage;
		21	import org.eclipse.mylar.internal.jira.JiraCustomQuery;
		22	import org.eclipse.mylar.internal.jira.JiraRepositoryQuery;
20	import org.eclipse.mylar.internal.jira.JiraServerFacade;	23	import org.eclipse.mylar.internal.jira.JiraServerFacade;
		24	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
		25	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
21	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	26	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
22	import org.eclipse.swt.SWT;	27	import org.eclipse.swt.SWT;
23	import org.eclipse.swt.events.SelectionAdapter;	28	import org.eclipse.swt.events.SelectionAdapter;
Lines 25-35 Link Here
25	import org.eclipse.swt.layout.GridData;	30	import org.eclipse.swt.layout.GridData;
26	import org.eclipse.swt.layout.GridLayout;	31	import org.eclipse.swt.layout.GridLayout;
27	import org.eclipse.swt.widgets.Button;	32	import org.eclipse.swt.widgets.Button;
28	import org.eclipse.swt.widgets.Combo;
29	import org.eclipse.swt.widgets.Composite;	33	import org.eclipse.swt.widgets.Composite;
30	import org.eclipse.swt.widgets.Display;	34	import org.eclipse.swt.widgets.Display;
31	import org.eclipse.swt.widgets.Label;	35	import org.eclipse.swt.widgets.List;
32	import org.tigris.jira.core.model.NamedFilter;	36	import org.tigris.jira.core.model.NamedFilter;
		37	import org.tigris.jira.core.model.filter.FilterDefinition;
33	import org.tigris.jira.core.service.JiraServer;	38	import org.tigris.jira.core.service.JiraServer;
34		39
35	/**	40	/**
Lines 38-66 Link Here
38	*	43	*
39	* @author Mik Kersten	44	* @author Mik Kersten
40	* @author Wesley Coelho (initial integration patch)	45	* @author Wesley Coelho (initial integration patch)
		46	* @author Eugene Kuleshov (layout and other improvements)
41	*/	47	*/
42	public class JiraQueryWizardPage extends WizardPage {	48	public class JiraQueryWizardPage extends WizardPage {
43		49
44	private static final int COMBO_WIDTH_HINT = 200;	50	// private static final int COMBO_WIDTH_HINT = 200;
45		51
46	private static final String TITLE = "New Jira Query";	52	private static final String TITLE = "New Jira Query";
47		53
48	private static final String DESCRIPTION = "Please select a filter defined on the server.";	54	private static final String DESCRIPTION = "Please select a filter defined on the server.";
49		55
50	private static final String COMBO_LABEL = "Filter:";	56	// private static final String COMBO_LABEL = "Filter:";
51		57
52	private static final String WAIT_MESSAGE = "Downloading...";	58	private static final String WAIT_MESSAGE = "Downloading...";
53		59
54	private static final String JOB_LABEL = "Downloading Filter Names";	60	private static final String JOB_LABEL = "Downloading Filter Names";
55		61
56	private NamedFilter[] filters = null;	62	NamedFilter[] filters = null;
57		63
58	private Combo filterCombo = null;	64	List filterCombo;
59		65
60	private TaskRepository repository;	66	TaskRepository repository;
		67
		68	Button updateButton = null;
		69
		70	private Button buttonCustom;
		71
		72	Button buttonSaved;
		73
		74	private FilterSummaryPage filterSummaryPage;
		75
		76	private AbstractRepositoryQuery query;
61		77
62	private Button updateButton = null;
63
64	public JiraQueryWizardPage(TaskRepository repository) {	78	public JiraQueryWizardPage(TaskRepository repository) {
65	super(TITLE);	79	super(TITLE);
66	this.repository = repository;	80	this.repository = repository;
Lines 69-75 Link Here
69	setPageComplete(false);	83	setPageComplete(false);
70	}	84	}
71		85
		86	public JiraQueryWizardPage(TaskRepository repository, AbstractRepositoryQuery query) {
		87	super(TITLE);
		88	this.repository = repository;
		89	this.query = query;
		90	setTitle(TITLE);
		91	setDescription(DESCRIPTION);
		92	setPageComplete(false);
		93	}
		94
72	public void createControl(Composite parent) {	95	public void createControl(Composite parent) {
		96	boolean isCustom = query==null \|\| query instanceof JiraCustomQuery;
		97	boolean isRepository = query instanceof JiraRepositoryQuery;
73		98
74	final Composite innerComposite = new Composite(parent, SWT.NONE);	99	final Composite innerComposite = new Composite(parent, SWT.NONE);
75	innerComposite.setLayoutData(new GridData());	100	innerComposite.setLayoutData(new GridData());
Lines 77-99 Link Here
77	gl.numColumns = 2;	102	gl.numColumns = 2;
78	innerComposite.setLayout(gl);	103	innerComposite.setLayout(gl);
79		104
80	Label label = new Label(innerComposite, SWT.NONE);	105	buttonCustom = new Button(innerComposite, SWT.RADIO);
81	label.setText(COMBO_LABEL);	106	buttonCustom.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, 2, 1));
82	label.setLayoutData(new GridData());	107	buttonCustom.setText("Custom Query");
		108	buttonCustom.setSelection(isCustom);
		109
		110	buttonSaved = new Button(innerComposite, SWT.RADIO);
		111	buttonSaved.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, 2, 1));
		112	buttonSaved.setText("Saved Query");
		113	buttonSaved.setSelection(isRepository);
		114
		115	buttonSaved.addSelectionListener(new SelectionAdapter() {
		116	public void widgetSelected(SelectionEvent e) {
		117	boolean selection = buttonSaved.getSelection();
		118	filterCombo.setEnabled(selection);
		119	updateButton.setEnabled(selection);
		120	setPageComplete(selection);
		121	}
		122	});
83		123
84	filterCombo = new Combo(innerComposite, SWT.READ_ONLY);	124	filterCombo = new List(innerComposite, SWT.V_SCROLL \| SWT.BORDER);
85	filterCombo.add(WAIT_MESSAGE);	125	filterCombo.add(WAIT_MESSAGE);
86	filterCombo.select(0);	126	filterCombo.select(0); // XXX
87		127
88	GridData data = new GridData();	128	GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
89	data.widthHint = COMBO_WIDTH_HINT;	129	data.horizontalIndent = 15;
90	filterCombo.setLayoutData(data);	130	filterCombo.setLayoutData(data);
		131	filterCombo.setEnabled(isRepository);
91		132
92	new Label(innerComposite, SWT.NULL); // spacer
93	updateButton = new Button(innerComposite, SWT.LEFT \| SWT.PUSH);	133	updateButton = new Button(innerComposite, SWT.LEFT \| SWT.PUSH);
94	updateButton.setText("Update Filters from Repository");	134	final GridData gridData = new GridData(SWT.FILL, SWT.TOP, false, true);
		135	updateButton.setLayoutData(gridData);
		136	updateButton.setText("Update from Repository");
		137	updateButton.setEnabled(isRepository);
95	updateButton.addSelectionListener(new SelectionAdapter() {	138	updateButton.addSelectionListener(new SelectionAdapter() {
96		139
97	@Override	140	@Override
98	public void widgetSelected(SelectionEvent e) {	141	public void widgetSelected(SelectionEvent e) {
99	filterCombo.removeAll();	142	filterCombo.removeAll();
Lines 102-114 Link Here
102	JiraServerFacade.getDefault().refreshServerSettings(repository);	145	JiraServerFacade.getDefault().refreshServerSettings(repository);
103	downloadFilters();	146	downloadFilters();
104	}	147	}
105		148
106	});	149	});
107		150
108	setControl(innerComposite);	151	setControl(innerComposite);
109	downloadFilters();	152	downloadFilters();
110	}	153	}
111		154
		155	public IWizardPage getNextPage() {
		156	if (!buttonCustom.getSelection()) {
		157	return null;
		158	}
		159	if (filterSummaryPage == null) {
		160	FilterDefinition workingCopy = new FilterDefinition();
		161	boolean isAdd = true;
		162
		163	filterSummaryPage = new FilterSummaryPage(repository, "summaryPage", "Filter Summary", null, workingCopy,
		164	isAdd);
		165	filterSummaryPage.setWizard(getWizard());
		166	}
		167	return filterSummaryPage;
		168	}
		169
		170	public boolean canFlipToNextPage() {
		171	return buttonCustom.getSelection();
		172	}
		173
112	protected void downloadFilters() {	174	protected void downloadFilters() {
113	Job job = new Job(JOB_LABEL) {	175	Job job = new Job(JOB_LABEL) {
114	@Override	176	@Override
Lines 144-163 Link Here
144		206
145	filterCombo.removeAll();	207	filterCombo.removeAll();
146		208
		209	String id = null;
		210	if(query instanceof JiraRepositoryQuery) {
		211	id = ((JiraRepositoryQuery) query).getNamedFilter().getId();
		212	}
		213
		214	int n = 0;
147	for (int i = 0; i < filters.length; i++) {	215	for (int i = 0; i < filters.length; i++) {
148	filterCombo.add(filters[i].getName());	216	filterCombo.add(filters[i].getName());
		217	if(filters[i].getId().equals(id)) {
		218	n = i;
		219	}
149	}	220	}
150		221
151	filterCombo.select(0);	222	filterCombo.select(n);
152	setPageComplete(true);	223	setPageComplete(true);
153	}	224	}
154		225
155	/** Returns the filter selected by the user or null on failure */	226	/** Returns the filter selected by the user or null on failure */
156	public NamedFilter getSelectedFilter() {	227	private NamedFilter getSelectedFilter() {
157	if (filters != null && filters.length > 0) {	228	if (filters != null && filters.length > 0) {
158	return filters[filterCombo.getSelectionIndex()];	229	return filters[filterCombo.getSelectionIndex()];
159	}	230	}
160	return null;	231	return null;
161	}	232	}
162		233
		234	public AbstractRepositoryQuery getQuery() {
		235	if (buttonSaved.getSelection()) {
		236	return new JiraRepositoryQuery(repository.getUrl(), getSelectedFilter(), MylarTaskListPlugin
		237	.getTaskListManager().getTaskList());
		238	}
		239
		240	if (filterSummaryPage != null) {
		241	return filterSummaryPage.getQuery();
		242	}
		243
		244	return null;
		245	}
		246
163	}	247	}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira.ui.wizards;

import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

/**
 * @author Rob Elves
 */
public class EditJiraQueryWizard extends Wizard {

	private static final String TITLE = "Edit Bugzilla Query";

	private final TaskRepository repository;

	private AbstractRepositoryQuery query;

	private JiraQueryWizardPage queryPage;

	public EditJiraQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {
		this.repository = repository;
		this.query = query;
		setNeedsProgressMonitor(true);
		setWindowTitle(TITLE);
	}

	@Override
	public void addPages() {
		queryPage = new JiraQueryWizardPage(repository, query);
		queryPage.setWizard(this);
		addPage(queryPage);
	}

	@Override
	public boolean performFinish() {

		AbstractRepositoryQuery q = queryPage.getQuery();
		if (q != null) {
			
//			String name;
//			if (q instanceof JiraRepositoryQuery) {
//				name = ((JiraRepositoryQuery) q).getNamedFilter().getName();
//			} else {
//				name = ((JiraCustomQuery) query).getFilterDefinition().getName();
//			}
			
			MylarTaskListPlugin.getTaskListManager().getTaskList().deleteQuery(query);
			MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(q);
			
			AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
			if (connector != null) {
				connector.synchronize(q, null);
			}
//			filter.refreshHits();
		} 

		return true;
	}

	@Override
	public boolean canFinish() {
		if(queryPage.getNextPage() == null) {
			return queryPage.isPageComplete();
		}
		return queryPage.getNextPage().isPageComplete();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project 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:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira;

import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.TaskList;
import org.tigris.jira.core.model.filter.FilterDefinition;

/**
 * A JiraFilter represents a query for issues from a Jira repository.
 * 
 * @author Mik Kersten
 */
public class JiraCustomQuery extends AbstractRepositoryQuery {

	private static final int MAX_HITS = 75;

	protected FilterDefinition filter = null;

//	private boolean isRefreshing = false;

	public JiraCustomQuery(String repositoryUrl, FilterDefinition filter, TaskList taskList) {
		super(filter.getName(), taskList);
		setMaxHits(MAX_HITS);
		this.filter = filter;
		super.repositoryUrl = repositoryUrl;
		setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getName());
//		super.setDescription(filter.getName());
	}

	public String getRepositoryKind() {
		return MylarJiraPlugin.REPOSITORY_KIND;
	}
	
	public FilterDefinition getFilterDefinition() {
		return filter;
	}
}

//public void refreshHits() {
//isRefreshing = true;
//Job j = new Job(LABEL_REFRESH_JOB) {
//
//	@Override
//	protected IStatus run(final IProgressMonitor monitor) {
//		clearHits();
//		try {
//			TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
//			JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
//
//				public void done() {
//					isRefreshing = false;
//					Display.getDefault().asyncExec(new Runnable() {
//						public void run() {
//							if (TaskListView.getDefault() != null)
//								TaskListView.getDefault().refreshAndFocus();
//						}
//					});
//				}
//
//				public boolean isCancelled() {
//					return monitor.isCanceled();
//				}
//
//				public void collectIssue(Issue issue) {
//					int issueId = new Integer(issue.getId());
//					JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
//					addHit(hit);
//				}
//
//				public void start() {
//
//				}
//			});
//
//		} catch (Exception e) {
//			isRefreshing = false;
//			JiraServerFacade.handleConnectionException(e);
//			return Status.CANCEL_STATUS;
//		}
//
//		return Status.OK_STATUS;
//	}
//
//};
//
//j.schedule();
//
//}

//public String getQueryUrl() {
//return super.getQueryUrl();
//}

//public String getPriority() {
//return "";
//}

//public String getDescription() {
//if (filter.getName() != null) {
//	return filter.getName();
//} else {
//	return super.getDescription();
//}
//}
//
//public void setDescription(String description) {
//filter.setDescription(description);
//}

//public boolean isLocal() {
//return false;
//}

///** True if the filter is currently downloading hits */
//public boolean isRefreshing() {
//return isRefreshing;
//}
//public void setRefreshing(boolean refreshing) {
//this.isRefreshing = refreshing;
//}




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project 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:
 *     Brock Janiczak - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira.ui.wizards;

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

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylar.internal.jira.JiraCustomQuery;
import org.eclipse.mylar.internal.jira.JiraServerFacade;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
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.graphics.Color;
import org.eclipse.swt.graphics.Image;
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.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.tigris.jira.core.model.Component;
import org.tigris.jira.core.model.Project;
import org.tigris.jira.core.model.Version;
import org.tigris.jira.core.model.filter.ComponentFilter;
import org.tigris.jira.core.model.filter.ContentFilter;
import org.tigris.jira.core.model.filter.FilterDefinition;
import org.tigris.jira.core.model.filter.ProjectFilter;
import org.tigris.jira.core.model.filter.VersionFilter;
import org.tigris.jira.core.service.JiraServer;

/**
 * @author Brock Janiczak
 * @author Eugene Kuleshov (layout and other improvements)
 */
public class FilterSummaryPage extends WizardPage {
	
	final Placeholder ANY_FIX_VERSION = new Placeholder("Any");

	final Placeholder NO_FIX_VERSION = new Placeholder("No Fix Version");

	final Placeholder ANY_REPORTED_VERSION = new Placeholder("Any");

	final Placeholder NO_REPORTED_VERSION = new Placeholder("No Version");

	final Placeholder UNRELEASED_VERSION = new Placeholder("Unreleased Versions");

	final Placeholder RELEASED_VERSION = new Placeholder("Released Versions");

	final Placeholder ANY_COMPONENT = new Placeholder("Any");

	final Placeholder NO_COMPONENT = new Placeholder("No Component");

	private final JiraServer server;

	private ListViewer project;

	private ListViewer reportedIn;

	private ListViewer components;

	private ListViewer fixFor;

	private final FilterDefinition workingCopy;

	private Text name;

	private Text description;

	private Text queryString;

	private Button searchSummary;

	private Button searchDescription;

	private Button searchComments;

	private Button searchEnvironment;

	private final boolean isNew;

	private IssueAttributesPage issueAttributesPage;

	private final TaskRepository repository;

	/**
	 * @param pageName
	 * @param title
	 * @param titleImage
	 */
	protected FilterSummaryPage(TaskRepository repository, String pageName, String title, ImageDescriptor titleImage,
			FilterDefinition workingCopy, boolean isNew) {
		super(pageName, title, titleImage);
		this.repository = repository;

		this.server = JiraServerFacade.getDefault().getJiraServer(repository);
		this.workingCopy = workingCopy;
		this.isNew = isNew;

		setPageComplete(false);
	}

	public void createControl(Composite parent) {
		GridData gd;
		Composite c = new Composite(parent, SWT.NONE);
		c.setLayout(new GridLayout(3, false));

		Label lblName = new Label(c, SWT.NONE);
		final GridData gridData = new GridData();
		lblName.setLayoutData(gridData);
		lblName.setText("Name:");

		name = new Text(c, SWT.BORDER);
		name.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1));
		name.addModifyListener(new ModifyListener() {

			public void modifyText(ModifyEvent e) {
				validatePage();
			}

		});

		if (!isNew) {
			name.setEnabled(false);
		}

		Label lblDescription = new Label(c, SWT.NONE);
		lblDescription.setText("Description:");
		lblDescription.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

		description = new Text(c, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1);
		gd.heightHint = 40;
		description.setLayoutData(gd);
		description.addFocusListener(new FocusAdapter() {

			public void focusLost(FocusEvent e) {
				validatePage();
			}

		});

		{
			Composite cc = new Composite(c, SWT.NONE);
			final GridData gridData_1 = new GridData(SWT.FILL, SWT.FILL, false, true, 3, 1);
			cc.setLayoutData(gridData_1);
			cc.setLayout(new GridLayout(4, false));

			Label lblProject = new Label(cc, SWT.NONE);
			lblProject.setText("Project:");

			Label lblFixFor = new Label(cc, SWT.NONE);
			lblFixFor.setText("Fix For:");
			lblFixFor.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

			Label lblComponent = new Label(cc, SWT.NONE);
			lblComponent.setText("In Components:");
			lblComponent.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

			Label lblReportedIn = new Label(cc, SWT.NONE);
			lblReportedIn.setText("Reported In:");
			lblReportedIn.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

			createProjectsViewer(cc);
			createFixForViewer(cc);
			createComponentsViewer(cc);
			createReportedInViewer(cc);

		}

		Label lblQuery = new Label(c, SWT.NONE);
		lblQuery.setLayoutData(new GridData());
		lblQuery.setText("Query:");
		queryString = new Text(c, SWT.BORDER);
		queryString.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1));
		// TODO put content assist here and a label describing what is available

		queryString.addFocusListener(new FocusAdapter() {

			public void focusLost(FocusEvent e) {
				validatePage();
			}

		});

		Label lblFields = new Label(c, SWT.NONE);
		lblFields.setText("Fields:");
		lblFields.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

		searchSummary = new Button(c, SWT.CHECK);
		searchSummary.setLayoutData(new GridData());
		searchSummary.setText("Summary");
		searchSummary.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}

		});

		searchDescription = new Button(c, SWT.CHECK);
		searchDescription.setLayoutData(new GridData());
		searchDescription.setText("Description");
		searchDescription.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}

		});
		new Label(c, SWT.NONE);

		// Need to turn off validation here
		if (isNew) {
			loadFromDefaults();
		} else {
			loadFromWorkingCopy();
		}

		setControl(c);

		searchComments = new Button(c, SWT.CHECK);
		searchComments.setLayoutData(new GridData());
		searchComments.setText("Comments");
		searchComments.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}

		});

		searchEnvironment = new Button(c, SWT.CHECK);
		searchEnvironment.setLayoutData(new GridData());
		searchEnvironment.setText("Environment");
		searchEnvironment.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}

		});
	}

	public IWizardPage getNextPage() {
		if (issueAttributesPage == null) {
			issueAttributesPage = new IssueAttributesPage(repository, "issueAttributes", "Issue Attributes", null,
					workingCopy, isNew);
			issueAttributesPage.setWizard(getWizard());
		}

		return issueAttributesPage;
	}

	private void createReportedInViewer(Composite c) {
		GridData gd;
		reportedIn = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		reportedIn.getControl().setLayoutData(gd);

		reportedIn.setContentProvider(new IStructuredContentProvider() {
			private Project project;

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

			public void dispose() {
			}

			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Version[] versions = project.getVersions();
					Version[] releasedVersions = project.getReleasedVersions();
					Version[] unreleasedVersions = project.getUnreleasedVersions();

					Object[] elements = new Object[versions.length + 4];
					elements[0] = ANY_REPORTED_VERSION;
					elements[1] = NO_REPORTED_VERSION;
					elements[2] = RELEASED_VERSION;
					System.arraycopy(releasedVersions, 0, elements, 3, releasedVersions.length);

					elements[releasedVersions.length + 3] = UNRELEASED_VERSION;

					System.arraycopy(unreleasedVersions, 0, elements, releasedVersions.length + 4,
							unreleasedVersions.length);
					return elements;
				}
				return new Object[] { ANY_REPORTED_VERSION };
			}

		});
		reportedIn.setLabelProvider(new VersionLabelProvider());
		reportedIn.setInput(null);
	}

	private void createComponentsViewer(Composite c) {
		GridData gd;
		components = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		components.getControl().setLayoutData(gd);

		components.setContentProvider(new IStructuredContentProvider() {
			private Project project;

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

			public void dispose() {
			}

			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Component[] components = project.getComponents();

					Object[] elements = new Object[components.length + 2];
					elements[0] = ANY_COMPONENT;
					elements[1] = NO_COMPONENT;
					System.arraycopy(components, 0, elements, 2, components.length);
					return elements;
				}
				return new Object[] { ANY_COMPONENT };
			}

		});
		components.setLabelProvider(new ComponentLabelProvider());
		components.setInput(null);
	}

	private void createFixForViewer(Composite c) {
		GridData gd;
		fixFor = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		fixFor.getControl().setLayoutData(gd);

		fixFor.setContentProvider(new IStructuredContentProvider() {
			private Project project;

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

			public void dispose() {
			}

			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Version[] versions = project.getVersions();
					Version[] releasedVersions = project.getReleasedVersions();
					Version[] unreleasedVersions = project.getUnreleasedVersions();

					Object[] elements = new Object[versions.length + 4];
					elements[0] = ANY_FIX_VERSION;
					elements[1] = NO_FIX_VERSION;
					elements[2] = RELEASED_VERSION;
					System.arraycopy(releasedVersions, 0, elements, 3, releasedVersions.length);

					elements[releasedVersions.length + 3] = UNRELEASED_VERSION;

					System.arraycopy(unreleasedVersions, 0, elements, releasedVersions.length + 4,
							unreleasedVersions.length);
					return elements;
				}
				return new Object[] { ANY_REPORTED_VERSION };
			}

		});
		fixFor.setLabelProvider(new VersionLabelProvider());
		fixFor.setInput(null);
	}

	private void createProjectsViewer(Composite c) {
		project = new ListViewer(c, SWT.V_SCROLL | SWT.MULTI | SWT.BORDER);
		project.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		project.setContentProvider(new IStructuredContentProvider() {

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

			public void dispose() {
			}

			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getProjects().length + 1];
				elements[0] = new Placeholder("All Projects");
				System.arraycopy(server.getProjects(), 0, elements, 1, server.getProjects().length);

				return elements;
			}

		});

		project.setLabelProvider(new LabelProvider() {

			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder) element).getText();
				}

				return ((Project) element).getName();
			}

		});

		project.setInput(server);
		project.addSelectionChangedListener(new ISelectionChangedListener() {

			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection selection = ((IStructuredSelection) event.getSelection());
				Project selectedProject = null;
				if (!selection.isEmpty() && !(selection.getFirstElement() instanceof Placeholder)) {
					selectedProject = (Project) selection.getFirstElement();
				}

				updateCurrentProject(selectedProject);
				validatePage();
			}

		});
	}

	void updateCurrentProject(Project project) {
		this.fixFor.setInput(project);
		this.components.setInput(project);
		this.reportedIn.setInput(project);

	}

	void validatePage() {
		if (name.getText().length() == 0) {
			setErrorMessage("Name is mandatory");
			setPageComplete(false);
			return;
		}

		setErrorMessage(null);
		setPageComplete(true);
	}

	private void loadFromDefaults() {
		project.setSelection(new StructuredSelection(new Placeholder("All Projects")));
		searchSummary.setSelection(true);
		searchDescription.setSelection(true);
	}

	private void loadFromWorkingCopy() {
		if (workingCopy.getName() != null) {
			name.setText(workingCopy.getName());
		}

		if (workingCopy.getDescription() != null) {
			description.setText(workingCopy.getDescription());
		}

		if (workingCopy.getProjectFilter() != null) {
			project.setSelection(new StructuredSelection(workingCopy.getProjectFilter().getProject()));
		} else {
			project.setSelection(new StructuredSelection(new Placeholder("All Projects")));
		}

		if (workingCopy.getFixForVersionFilter() != null) {
			if (workingCopy.getFixForVersionFilter().hasNoVersion()) {
				fixFor.setSelection(new StructuredSelection(new Object[] { NO_FIX_VERSION }));
			} else if (workingCopy.getFixForVersionFilter().isReleasedVersions()
					&& workingCopy.getFixForVersionFilter().isUnreleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(new Object[] { RELEASED_VERSION, UNRELEASED_VERSION }));
			} else if (workingCopy.getFixForVersionFilter().isReleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(RELEASED_VERSION));
			} else if (workingCopy.getFixForVersionFilter().isUnreleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(UNRELEASED_VERSION));
			} else {
				fixFor.setSelection(new StructuredSelection(workingCopy.getFixForVersionFilter().getVersions()));
			}
		} else {
			fixFor.setSelection(new StructuredSelection(ANY_FIX_VERSION));
		}

		if (workingCopy.getReportedInVersionFilter() != null) {
			if (workingCopy.getReportedInVersionFilter().hasNoVersion()) {
				reportedIn.setSelection(new StructuredSelection(new Object[] { NO_REPORTED_VERSION }));
			} else if (workingCopy.getReportedInVersionFilter().isReleasedVersions()
					&& workingCopy.getReportedInVersionFilter().isUnreleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(new Object[] { RELEASED_VERSION, UNRELEASED_VERSION }));
			} else if (workingCopy.getReportedInVersionFilter().isReleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(RELEASED_VERSION));
			} else if (workingCopy.getReportedInVersionFilter().isUnreleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(UNRELEASED_VERSION));
			} else {
				reportedIn
						.setSelection(new StructuredSelection(workingCopy.getReportedInVersionFilter().getVersions()));
			}
		} else {
			reportedIn.setSelection(new StructuredSelection(ANY_REPORTED_VERSION));
		}

		if (workingCopy.getContentFilter() != null) {
			this.queryString.setText(workingCopy.getContentFilter().getQueryString());
			this.searchComments.setSelection(workingCopy.getContentFilter().isSearchingComments());
			this.searchDescription.setSelection(workingCopy.getContentFilter().isSearchingDescription());
			this.searchEnvironment.setSelection(workingCopy.getContentFilter().isSearchingEnvironment());
			this.searchSummary.setSelection(workingCopy.getContentFilter().isSearchingSummary());
		}

		if (workingCopy.getComponentFilter() != null) {
			if (workingCopy.getComponentFilter().hasNoComponent()) {
				components.setSelection(new StructuredSelection(NO_COMPONENT));
			} else {
				components.setSelection(new StructuredSelection(workingCopy.getComponentFilter().getComponents()));
			}
		} else {
			components.setSelection(new StructuredSelection(ANY_COMPONENT));
		}
	}

	/* default */void applyChanges() {
		workingCopy.setName(this.name.getText());
		workingCopy.setDescription(this.description.getText());
		if (this.queryString.getText().length() > 0 || this.searchSummary.getSelection()
				|| this.searchDescription.getSelection() || this.searchEnvironment.getSelection()
				|| this.searchComments.getSelection()) {
			workingCopy.setContentFilter(new ContentFilter(this.queryString.getText(), this.searchSummary
					.getSelection(), this.searchDescription.getSelection(), this.searchEnvironment.getSelection(),
					this.searchComments.getSelection()));
		} else {
			workingCopy.setContentFilter(null);
		}

		IStructuredSelection projectSelection = (IStructuredSelection) this.project.getSelection();
		if (!projectSelection.isEmpty() && projectSelection.getFirstElement() instanceof Project) {
			workingCopy.setProjectFilter(new ProjectFilter((Project) projectSelection.getFirstElement()));
		} else {
			workingCopy.setProjectFilter(null);
		}

		IStructuredSelection reportedInSelection = (IStructuredSelection) reportedIn.getSelection();
		if (reportedInSelection.isEmpty()) {
			workingCopy.setReportedInVersionFilter(null);
		} else {
			boolean selectionContainsReleased = false;
			boolean selectionContainsUnreleased = false;
			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;

			List<Version> selectedVersions = new ArrayList<Version>();

			for (Iterator i = reportedInSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_REPORTED_VERSION.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_REPORTED_VERSION.equals(selection)) {
					selectionContainsNone = true;
				} else if (RELEASED_VERSION.equals(selection)) {
					selectionContainsReleased = true;
				} else if (UNRELEASED_VERSION.equals(selection)) {
					selectionContainsUnreleased = true;
				} else if (selection instanceof Version) {
					selectedVersions.add((Version) selection);
				}
			}

			if (selectionContainsAll) {
				workingCopy.setReportedInVersionFilter(null);
			} else if (selectionContainsNone) {
				workingCopy.setReportedInVersionFilter(new VersionFilter(new Version[0]));
			} else if (selectionContainsReleased || selectionContainsUnreleased) {
				workingCopy.setReportedInVersionFilter(new VersionFilter(selectionContainsReleased,
						selectionContainsUnreleased));
			} else if (selectedVersions.size() > 0) {
				workingCopy.setReportedInVersionFilter(
						new VersionFilter(selectedVersions.toArray(new Version[selectedVersions.size()])));
			} else {
				workingCopy.setReportedInVersionFilter(null);
			}
		}

		IStructuredSelection fixForSelection = (IStructuredSelection) fixFor.getSelection();
		if (fixForSelection.isEmpty()) {
			workingCopy.setFixForVersionFilter(null);
		} else {
			boolean selectionContainsReleased = false;
			boolean selectionContainsUnreleased = false;
			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;

			List<Version> selectedVersions = new ArrayList<Version>();

			for (Iterator i = fixForSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_FIX_VERSION.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_FIX_VERSION.equals(selection)) {
					selectionContainsNone = true;
				} else if (RELEASED_VERSION.equals(selection)) {
					selectionContainsReleased = true;
				} else if (UNRELEASED_VERSION.equals(selection)) {
					selectionContainsUnreleased = true;
				} else if (selection instanceof Version) {
					selectedVersions.add((Version) selection);
				}
			}

			if (selectionContainsAll) {
				workingCopy.setFixForVersionFilter(null);
			} else if (selectionContainsNone) {
				workingCopy.setFixForVersionFilter(new VersionFilter(new Version[0]));
			} else if (selectionContainsReleased || selectionContainsUnreleased) {
				workingCopy.setFixForVersionFilter(new VersionFilter(selectionContainsReleased,
						selectionContainsUnreleased));
			} else if (selectedVersions.size() > 0) {
				workingCopy.setFixForVersionFilter(
						new VersionFilter(selectedVersions.toArray(new Version[selectedVersions.size()])));
			} else {
				workingCopy.setFixForVersionFilter(null);
			}
		}

		IStructuredSelection componentsSelection = (IStructuredSelection) components.getSelection();
		if (componentsSelection.isEmpty()) {
			workingCopy.setComponentFilter(null);
		} else {

			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;
			List<Component> selectedComponents = new ArrayList<Component>();

			for (Iterator i = componentsSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_COMPONENT.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_COMPONENT.equals(selection)) {
					selectionContainsNone = true;
				} else if (selection instanceof Component) {
					selectedComponents.add((Component) selection);
				}
			}

			if (selectionContainsAll) {
				workingCopy.setComponentFilter(null);
			} else if (selectedComponents.size() > 0) {
				workingCopy.setComponentFilter(
						new ComponentFilter(selectedComponents.toArray(new Component[selectedComponents.size()])));
			} else if (selectionContainsNone) {
				workingCopy.setComponentFilter(new ComponentFilter(new Component[0]));
			} else {
				workingCopy.setComponentFilter(null);
			}
		}
	}

	final class ComponentLabelProvider implements ILabelProvider {

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

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			if (element instanceof Placeholder) {
				return ((Placeholder) element).getText();
			}
			return ((Component) element).getName();
		}

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

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

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

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

	}

	final class VersionLabelProvider implements ILabelProvider, IColorProvider {

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

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			if (element instanceof Placeholder) {
				return ((Placeholder) element).getText();
			}
			return ((Version) element).getName();
		}

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

		}

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

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

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

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
		 */
		public Color getForeground(Object element) {
			return null;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
		 */
		public Color getBackground(Object element) {
			if (element instanceof Placeholder) {
				return Display.getCurrent().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
			}
			return null;
		}

	}

	private final class Placeholder {
		private final String text;

		public Placeholder(String text) {
			this.text = text;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (obj == null)
				return false;
			if (!(obj instanceof Placeholder))
				return false;

			Placeholder that = (Placeholder) obj;
			return this.text.equals(that.text);
		}

		public String getText() {
			return this.text;
		}
	}

	public AbstractRepositoryQuery getQuery() {
		this.applyChanges();
		issueAttributesPage.applyChanges();
		if (isNew) {
			server.addLocalFilter(workingCopy);
		}

		return new JiraCustomQuery(repository.getUrl(), workingCopy, MylarTaskListPlugin.getTaskListManager()
				.getTaskList());
	}
}




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project 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:
 *     Brock Janiczak - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira.ui.wizards;

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

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylar.internal.jira.JiraServerFacade;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.tigris.jira.core.model.IssueType;
import org.tigris.jira.core.model.Priority;
import org.tigris.jira.core.model.Resolution;
import org.tigris.jira.core.model.Status;
import org.tigris.jira.core.model.filter.CurrentUserFilter;
import org.tigris.jira.core.model.filter.FilterDefinition;
import org.tigris.jira.core.model.filter.IssueTypeFilter;
import org.tigris.jira.core.model.filter.NobodyFilter;
import org.tigris.jira.core.model.filter.PriorityFilter;
import org.tigris.jira.core.model.filter.ResolutionFilter;
import org.tigris.jira.core.model.filter.SpecificUserFilter;
import org.tigris.jira.core.model.filter.StatusFilter;
import org.tigris.jira.core.model.filter.UserFilter;
import org.tigris.jira.core.model.filter.UserInGroupFilter;
import org.tigris.jira.core.service.JiraServer;

/**
 * @author Brock Janiczak
 * @author Eugene Kuleshov (layout and other improvements)
 */
public class IssueAttributesPage extends WizardPage {
	final Placeholder ANY_ISSUE_TYPE = new Placeholder("Any");

	final Placeholder ANY_RESOLUTION = new Placeholder("Any");

	final Placeholder UNRESOLVED = new Placeholder("Unresolved");

	final Placeholder UNASSIGNED = new Placeholder("Unassigned");

	final Placeholder ANY_REPORTER = new Placeholder("Any");

	final Placeholder NO_REPORTER = new Placeholder("No Reporter");

	final Placeholder CURRENT_USER_REPORTER = new Placeholder("Current User");

	final Placeholder SPECIFIC_USER_REPORTER = new Placeholder("Specified User");

	final Placeholder SPECIFIC_GROUP_REPORTER = new Placeholder("Specified Group");

	final Placeholder ANY_ASSIGNEE = new Placeholder("Any");

	final Placeholder CURRENT_USER_ASSIGNEE = new Placeholder("Current User");

	final Placeholder SPECIFIC_USER_ASSIGNEE = new Placeholder("Specified User");

	final Placeholder SPECIFIC_GROUP_ASSIGNEE = new Placeholder("Specified Group");

	final Placeholder ANY_STATUS = new Placeholder("Any");

	final Placeholder ANY_PRIORITY = new Placeholder("Any");

//	private final TaskRepository repository;

	private final JiraServer jiraServer;

	private final FilterDefinition workingCopy;

	private final boolean isNew;

	private ListViewer issueType;

	private ComboViewer reporterType;

	private ComboViewer assigneeType;

	private ListViewer status;

	private ListViewer resolution;

	private ListViewer priority;

	Text assignee;

	Text reporter;

	/**
	 * @param repository
	 * @param pageName
	 * @param title
	 * @param titleImage
	 * @param server
	 */
	protected IssueAttributesPage(TaskRepository repository, String pageName, String title, ImageDescriptor titleImage,
			FilterDefinition workingCopy, boolean isNew) {
		super(pageName, title, titleImage);
//		this.repository = repository;
		this.jiraServer = JiraServerFacade.getDefault().getJiraServer(repository);
		this.workingCopy = workingCopy;
		this.isNew = isNew;

		setPageComplete(false);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		GridData gd;

		Composite cc = new Composite(parent, SWT.NONE);
		cc.setLayout(new GridLayout(1, false));

		{
			Composite c = new Composite(cc, SWT.NONE);
			final GridData gridData = new GridData(SWT.FILL, SWT.TOP, true, false);
			gridData.widthHint = 515;
			c.setLayoutData(gridData);
			c.setLayout(new GridLayout(3, false));

			Label lblReportedBy = new Label(c, SWT.NONE);
			lblReportedBy.setText("Reported By:");
			lblReportedBy.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

			reporterType = new ComboViewer(c, SWT.BORDER | SWT.READ_ONLY);
			final GridData gridData_1 = new GridData(SWT.FILL, SWT.FILL, false, false);
			gridData_1.widthHint = 133;
			reporterType.getControl().setLayoutData(gridData_1);

			reporterType.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					return new Object[] { ANY_REPORTER, NO_REPORTER, CURRENT_USER_REPORTER, SPECIFIC_USER_REPORTER,
							SPECIFIC_GROUP_REPORTER };
				}

			});

			reporterType.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					return ((Placeholder) element).getText();
				}

			});

			reporterType.setInput(jiraServer);

			reporter = new Text(c, SWT.BORDER);
			reporter.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
			reporter.setEnabled(false);

			reporter.addModifyListener(new ModifyListener() {

				public void modifyText(ModifyEvent e) {
					validatePage();
				}

			});

			Label lblAssignedTo = new Label(c, SWT.NONE);
			lblAssignedTo.setText("Assigned To:");
			lblAssignedTo.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

			assigneeType = new ComboViewer(c, SWT.BORDER | SWT.READ_ONLY);
			final GridData gridData_2 = new GridData(SWT.FILL, SWT.FILL, false, false);
			gridData_2.widthHint = 118;
			assigneeType.getControl().setLayoutData(gridData_2);

			assigneeType.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					return new Object[] { ANY_ASSIGNEE, UNASSIGNED, CURRENT_USER_ASSIGNEE, SPECIFIC_USER_ASSIGNEE,
							SPECIFIC_GROUP_ASSIGNEE };
				}

			});

			assigneeType.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					return ((Placeholder) element).getText();
				}

			});

			assigneeType.setInput(jiraServer);
			assigneeType.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
					if (SPECIFIC_USER_ASSIGNEE.equals(selection) || SPECIFIC_GROUP_ASSIGNEE.equals(selection)) {
						assignee.setEnabled(true);
					} else {
						assignee.setEnabled(false);
						assignee.setText(""); //$NON-NLS-1$
					}
					validatePage();
				}

			});

			reporterType.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
					if (SPECIFIC_USER_REPORTER.equals(selection) || SPECIFIC_GROUP_REPORTER.equals(selection)) {
						reporter.setEnabled(true);
					} else {
						reporter.setEnabled(false);
					}
				}

			});

			assignee = new Text(c, SWT.BORDER);
			assignee.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
			assignee.setEnabled(false);

			assignee.addModifyListener(new ModifyListener() {

				public void modifyText(ModifyEvent e) {
					validatePage();
				}

			});

		}

		{
			Composite c = new Composite(cc, SWT.NONE);
			final GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
			gridData.heightHint = 149;
			c.setLayoutData(gridData);
			c.setLayout(new GridLayout(4, false));

			Label lblIssueType = new Label(c, SWT.NONE);
			lblIssueType.setText("Type:");
			lblIssueType.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false));

			Label lblStatus = new Label(c, SWT.NONE);
			lblStatus.setText("Status:");
			lblStatus.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false));

			Label lblResolution = new Label(c, SWT.NONE);
			lblResolution.setText("Resolution:");
			lblResolution.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false));

			Label lblPriority = new Label(c, SWT.NONE);
			lblPriority.setText("Priority:");
			lblPriority.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false));
			
			issueType = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
			gd = new GridData(SWT.FILL, SWT.FILL, true, true);
			gd.heightHint = 40;
			issueType.getControl().setLayoutData(gd);

			issueType.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					JiraServer server = (JiraServer) inputElement;
					Object[] elements = new Object[server.getIssueTypes().length + 1];
					elements[0] = ANY_ISSUE_TYPE;
					System.arraycopy(server.getIssueTypes(), 0, elements, 1, server.getIssueTypes().length);

					return elements;
				}
			});

			issueType.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					if (element instanceof Placeholder) {
						return ((Placeholder) element).getText();
					}

					return ((IssueType) element).getName();
				}

			});

			issueType.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					validatePage();
				}

			});
			issueType.setInput(jiraServer);

			status = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
			gd = new GridData(SWT.FILL, SWT.FILL, true, true);
			gd.heightHint = 40;
			status.getControl().setLayoutData(gd);

			status.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					JiraServer server = (JiraServer) inputElement;
					Object[] elements = new Object[server.getStatuses().length + 1];
					elements[0] = ANY_STATUS;
					System.arraycopy(server.getStatuses(), 0, elements, 1, server.getStatuses().length);

					return elements;
				}
			});

			status.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					if (element instanceof Placeholder) {
						return ((Placeholder) element).getText();
					}

					return ((Status) element).getName();
				}

			});

			status.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					validatePage();
				}

			});
			status.setInput(jiraServer);

			resolution = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
			gd = new GridData(SWT.FILL, SWT.FILL, true, true);
			gd.heightHint = 40;
			resolution.getControl().setLayoutData(gd);
			resolution.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					JiraServer server = (JiraServer) inputElement;
					Object[] elements = new Object[server.getResolutions().length + 2];
					elements[0] = ANY_RESOLUTION;
					elements[1] = UNRESOLVED;
					System.arraycopy(server.getResolutions(), 0, elements, 2, server.getResolutions().length);

					return elements;
				}
			});

			resolution.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					if (element instanceof Placeholder) {
						return ((Placeholder) element).getText();
					}

					return ((Resolution) element).getName();
				}

			});

			resolution.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					validatePage();
				}

			});
			resolution.setInput(jiraServer);

			priority = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
			gd = new GridData(SWT.FILL, SWT.FILL, true, true);
			gd.heightHint = 40;
			priority.getControl().setLayoutData(gd);

			priority.setContentProvider(new IStructuredContentProvider() {

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

				public void dispose() {
				}

				public Object[] getElements(Object inputElement) {
					JiraServer server = (JiraServer) inputElement;
					Object[] elements = new Object[server.getPriorities().length + 1];
					elements[0] = ANY_PRIORITY;
					System.arraycopy(server.getPriorities(), 0, elements, 1, server.getPriorities().length);

					return elements;
				}
			});

			priority.setLabelProvider(new LabelProvider() {

				public String getText(Object element) {
					if (element instanceof Placeholder) {
						return ((Placeholder) element).getText();
					}

					return ((Priority) element).getName();
				}

			});
			priority.addSelectionChangedListener(new ISelectionChangedListener() {

				public void selectionChanged(SelectionChangedEvent event) {
					validatePage();
				}

			});
			priority.setInput(jiraServer);
		}

		if (isNew) {
			loadFromDefaults();
		} else {
			loadFromWorkingCopy();
		}

		setControl(cc);
	}

	void validatePage() {

	}

	/* default */void applyChanges() {
		if(issueType==null) {
			return;
		}
		
		// TODO support standard and subtask issue types
		IStructuredSelection issueTypeSelection = (IStructuredSelection) issueType.getSelection();
		if (issueTypeSelection.isEmpty()) {
			workingCopy.setIssueTypeFilter(null);
		} else {
			boolean isAnyIssueTypeSelected = false;

			List<IssueType> selectedIssueTypes = new ArrayList<IssueType>();

			for (Iterator i = issueTypeSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_ISSUE_TYPE.equals(selection)) {
					isAnyIssueTypeSelected = true;
				} else if (selection instanceof IssueType) {
					selectedIssueTypes.add((IssueType) selection);
				}
			}

			if (isAnyIssueTypeSelected) {
				workingCopy.setIssueTypeFilter(null);
			} else {
				workingCopy.setIssueTypeFilter(
					new IssueTypeFilter(selectedIssueTypes.toArray(new IssueType[selectedIssueTypes.size()])));
			}
		}

		IStructuredSelection reporterSelection = (IStructuredSelection) reporterType.getSelection();
		if (reporterSelection.isEmpty()) {
			workingCopy.setReportedByFilter(null);
		} else {
			if (ANY_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(null);
			} else if (NO_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new NobodyFilter());
			} else if (CURRENT_USER_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new CurrentUserFilter());
			} else if (SPECIFIC_GROUP_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new UserInGroupFilter(reporter.getText()));
			} else if (SPECIFIC_USER_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new SpecificUserFilter(reporter.getText()));
			} else {
				workingCopy.setReportedByFilter(null);
			}
		}

		IStructuredSelection assigneeSelection = (IStructuredSelection) assigneeType.getSelection();
		if (assigneeSelection.isEmpty()) {
			workingCopy.setAssignedToFilter(null);
		} else {
			if (ANY_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(null);
			} else if (UNASSIGNED.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new NobodyFilter());
			} else if (CURRENT_USER_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new CurrentUserFilter());
			} else if (SPECIFIC_GROUP_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new UserInGroupFilter(assignee.getText()));
			} else if (SPECIFIC_USER_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new SpecificUserFilter(assignee.getText()));
			} else {
				workingCopy.setAssignedToFilter(null);
			}
		}

		IStructuredSelection statusSelection = (IStructuredSelection) status.getSelection();
		if (statusSelection.isEmpty()) {
			workingCopy.setStatusFilter(null);
		} else {
			boolean isAnyStatusSelected = false;

			List<Status> selectedStatuses = new ArrayList<Status>();

			for (Iterator i = statusSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_STATUS.equals(selection)) {
					isAnyStatusSelected = true;
				} else if (selection instanceof Status) {
					selectedStatuses.add((Status) selection);
				}
			}

			if (isAnyStatusSelected) {
				workingCopy.setStatusFilter(null);
			} else {
				workingCopy.setStatusFilter(
					new StatusFilter(selectedStatuses.toArray(new Status[selectedStatuses.size()])));
			}
		}

		IStructuredSelection resolutionSelection = (IStructuredSelection) resolution.getSelection();
		if (resolutionSelection.isEmpty()) {
			workingCopy.setResolutionFilter(null);
		} else {
			boolean isAnyResolutionSelected = false;

			List<Resolution> selectedResolutions = new ArrayList<Resolution>();

			for (Iterator i = resolutionSelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_RESOLUTION.equals(selection)) {
					isAnyResolutionSelected = true;
				} else if (selection instanceof Resolution) {
					selectedResolutions.add((Resolution) selection);
				}
			}

			if (isAnyResolutionSelected) {
				workingCopy.setResolutionFilter(null);
			} else {
				workingCopy.setResolutionFilter(
					new ResolutionFilter(selectedResolutions.toArray(new Resolution[selectedResolutions.size()])));
			}
		}

		IStructuredSelection prioritySelection = (IStructuredSelection) priority.getSelection();
		if (prioritySelection.isEmpty()) {
			workingCopy.setPriorityFilter(null);
		} else {
			boolean isAnyPrioritiesSelected = false;

			List<Priority> selectedPriorities = new ArrayList<Priority>();

			for (Iterator i = prioritySelection.iterator(); i.hasNext();) {
				Object selection = i.next();
				if (ANY_PRIORITY.equals(selection)) {
					isAnyPrioritiesSelected = true;
				} else if (selection instanceof Priority) {
					selectedPriorities.add((Priority) selection);
				}
			}

			if (isAnyPrioritiesSelected) {
				workingCopy.setPriorityFilter(null);
			} else {
				workingCopy.setPriorityFilter(
					new PriorityFilter(selectedPriorities.toArray(new Priority[selectedPriorities.size()])));
			}
		}
	}

	private void loadFromDefaults() {
		issueType.setSelection(new StructuredSelection(ANY_ISSUE_TYPE));
		reporterType.setSelection(new StructuredSelection(ANY_REPORTER));
		assigneeType.setSelection(new StructuredSelection(ANY_ASSIGNEE));
		status.setSelection(new StructuredSelection(ANY_STATUS));
		resolution.setSelection(new StructuredSelection(ANY_RESOLUTION));
		priority.setSelection(new StructuredSelection(ANY_PRIORITY));
	}

	private void loadFromWorkingCopy() {
		if (workingCopy.getIssueTypeFilter() != null) {
			issueType.setSelection(new StructuredSelection(workingCopy.getIssueTypeFilter().getIsueTypes()));
		} else {
			issueType.setSelection(new StructuredSelection(ANY_ISSUE_TYPE));
		}

		if (workingCopy.getReportedByFilter() != null) {
			UserFilter reportedByFilter = workingCopy.getReportedByFilter();
			if (reportedByFilter instanceof NobodyFilter) {
				reporterType.setSelection(new StructuredSelection(NO_REPORTER));
			} else if (reportedByFilter instanceof CurrentUserFilter) {
				reporterType.setSelection(new StructuredSelection(CURRENT_USER_REPORTER));
			} else if (reportedByFilter instanceof SpecificUserFilter) {
				reporterType.setSelection(new StructuredSelection(SPECIFIC_USER_REPORTER));
				reporter.setText(((SpecificUserFilter) reportedByFilter).getUser());
			} else if (reportedByFilter instanceof UserInGroupFilter) {
				reporterType.setSelection(new StructuredSelection(SPECIFIC_GROUP_REPORTER));
				reporter.setText(((UserInGroupFilter) reportedByFilter).getGroup());
			}
		} else {
			reporterType.setSelection(new StructuredSelection(ANY_REPORTER));
		}

		if (workingCopy.getAssignedToFilter() != null) {
			UserFilter assignedToFilter = workingCopy.getAssignedToFilter();
			if (assignedToFilter instanceof NobodyFilter) {
				assigneeType.setSelection(new StructuredSelection(UNASSIGNED));
			} else if (assignedToFilter instanceof CurrentUserFilter) {
				assigneeType.setSelection(new StructuredSelection(CURRENT_USER_ASSIGNEE));
			} else if (assignedToFilter instanceof SpecificUserFilter) {
				assigneeType.setSelection(new StructuredSelection(SPECIFIC_USER_ASSIGNEE));
				assignee.setText(((SpecificUserFilter) assignedToFilter).getUser());
			} else if (assignedToFilter instanceof UserInGroupFilter) {
				assigneeType.setSelection(new StructuredSelection(SPECIFIC_GROUP_ASSIGNEE));
				assignee.setText(((UserInGroupFilter) assignedToFilter).getGroup());
			}
		} else {
			assigneeType.setSelection(new StructuredSelection(ANY_ASSIGNEE));
		}

		if (workingCopy.getStatusFilter() != null) {
			status.setSelection(new StructuredSelection(workingCopy.getStatusFilter().getStatuses()));
		} else {
			status.setSelection(new StructuredSelection(ANY_STATUS));
		}

		if (workingCopy.getResolutionFilter() != null) {
			resolution.setSelection(new StructuredSelection(workingCopy.getResolutionFilter().getResolutions()));
		} else {
			resolution.setSelection(new StructuredSelection(ANY_RESOLUTION));
		}

		if (workingCopy.getPriorityFilter() != null) {
			priority.setSelection(new StructuredSelection(workingCopy.getPriorityFilter().getPriorities()));
		} else {
			priority.setSelection(new StructuredSelection(ANY_PRIORITY));
		}
	}

	private final class Placeholder {
		private final String text;

		public Placeholder(String text) {
			this.text = text;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (obj == null)
				return false;
			if (!(obj instanceof Placeholder))
				return false;

			Placeholder that = (Placeholder) obj;
			return this.text.equals(that.text);
		}

		public String getText() {
			return this.text;
		}
	}
}

Return to bug 129086

Lines 12-22 Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/NewJiraQueryWizard.java (-8 / +16 lines)
12	package org.eclipse.mylar.internal.jira.ui.wizards;	12	package org.eclipse.mylar.internal.jira.ui.wizards;
13		13
14	import org.eclipse.jface.wizard.Wizard;	14	import org.eclipse.jface.wizard.Wizard;
15	import org.eclipse.mylar.internal.jira.JiraRepositoryQuery;
16	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;	15	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
		16	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
17	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;	17	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
18	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	18	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
19	import org.tigris.jira.core.model.NamedFilter;
20		19
21	/**	20	/**
22	* Wizard that allows the user to select one of their named Jira filters on the	21	* Wizard that allows the user to select one of their named Jira filters on the
Lines 24-29 Link Here
24	*	23	*
25	* @author Mik Kersten	24	* @author Mik Kersten
26	* @author Wesley Coelho (initial integration patch)	25	* @author Wesley Coelho (initial integration patch)
		26	* @author Eugene Kuleshov (integration with editor pages)
27	*/	27	*/
28	public class NewJiraQueryWizard extends Wizard {	28	public class NewJiraQueryWizard extends Wizard {
29		29
Lines 42-61 Link Here
42	@Override	42	@Override
43	public void addPages() {	43	public void addPages() {
44	queryPage = new JiraQueryWizardPage(repository);	44	queryPage = new JiraQueryWizardPage(repository);
		45	queryPage.setWizard(this);
45	addPage(queryPage);	46	addPage(queryPage);
46	}	47	}
47		48
48	@Override	49	@Override
49	public boolean performFinish() {	50	public boolean performFinish() {
50		51
51	NamedFilter namedFilter = queryPage.getSelectedFilter();	52	AbstractRepositoryQuery query = queryPage.getQuery();
52		53	if (query != null) {
53	if (namedFilter != null) {	54	MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(query);
54	JiraRepositoryQuery filter = new JiraRepositoryQuery(repository.getUrl(), namedFilter, MylarTaskListPlugin.getTaskListManager().getTaskList());
55	MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(filter);
56	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());	55	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
57	if (connector != null) {	56	if (connector != null) {
58	connector.synchronize(filter, null);	57	connector.synchronize(query, null);
59	}	58	}
60	// filter.refreshHits();	59	// filter.refreshHits();
61	}	60	}
Lines 63-66 Link Here
63	return true;	62	return true;
64	}	63	}
65		64
		65
		66
		67	public boolean canFinish() {
		68	if(queryPage.getNextPage() == null) {
		69	return queryPage.isPageComplete();
		70	}
		71	return queryPage.getNextPage().isPageComplete();
		72	}
		73
66	}	74	}

Added Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/EditJiraQueryWizard.java (+80 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia 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	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.jira.ui.wizards;
13
14	import org.eclipse.jface.wizard.Wizard;
15	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
16	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
17	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
18	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
19
20	/**
21	* @author Rob Elves
22	*/
23	public class EditJiraQueryWizard extends Wizard {
24
25	private static final String TITLE = "Edit Bugzilla Query";
26
27	private final TaskRepository repository;
28
29	private AbstractRepositoryQuery query;
30
31	private JiraQueryWizardPage queryPage;
32
33	public EditJiraQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {
34	this.repository = repository;
35	this.query = query;
36	setNeedsProgressMonitor(true);
37	setWindowTitle(TITLE);
38	}
39
40	@Override
41	public void addPages() {
42	queryPage = new JiraQueryWizardPage(repository, query);
43	queryPage.setWizard(this);
44	addPage(queryPage);
45	}
46
47	@Override
48	public boolean performFinish() {
49
50	AbstractRepositoryQuery q = queryPage.getQuery();
51	if (q != null) {
52
53	// String name;
54	// if (q instanceof JiraRepositoryQuery) {
55	// name = ((JiraRepositoryQuery) q).getNamedFilter().getName();
56	// } else {
57	// name = ((JiraCustomQuery) query).getFilterDefinition().getName();
58	// }
59
60	MylarTaskListPlugin.getTaskListManager().getTaskList().deleteQuery(query);
61	MylarTaskListPlugin.getTaskListManager().getTaskList().addQuery(q);
62
63	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
64	if (connector != null) {
65	connector.synchronize(q, null);
66	}
67	// filter.refreshHits();
68	}
69
70	return true;
71	}
72
73	@Override
74	public boolean canFinish() {
75	if(queryPage.getNextPage() == null) {
76	return queryPage.isPageComplete();
77	}
78	return queryPage.getNextPage().isPageComplete();
79	}
80	}

Added Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraCustomQuery.java (+130 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 - 2006 Mylar eclipse.org project 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	* Mylar project committers - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.jira;
13
14	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
15	import org.eclipse.mylar.provisional.tasklist.TaskList;
16	import org.tigris.jira.core.model.filter.FilterDefinition;
17
18	/**
19	* A JiraFilter represents a query for issues from a Jira repository.
20	*
21	* @author Mik Kersten
22	*/
23	public class JiraCustomQuery extends AbstractRepositoryQuery {
24
25	private static final int MAX_HITS = 75;
26
27	protected FilterDefinition filter = null;
28
29	// private boolean isRefreshing = false;
30
31	public JiraCustomQuery(String repositoryUrl, FilterDefinition filter, TaskList taskList) {
32	super(filter.getName(), taskList);
33	setMaxHits(MAX_HITS);
34	this.filter = filter;
35	super.repositoryUrl = repositoryUrl;
36	setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getName());
37	// super.setDescription(filter.getName());
38	}
39
40	public String getRepositoryKind() {
41	return MylarJiraPlugin.REPOSITORY_KIND;
42	}
43
44	public FilterDefinition getFilterDefinition() {
45	return filter;
46	}
47	}
48
49	//public void refreshHits() {
50	//isRefreshing = true;
51	//Job j = new Job(LABEL_REFRESH_JOB) {
52	//
53	// @Override
54	// protected IStatus run(final IProgressMonitor monitor) {
55	// clearHits();
56	// try {
57	// TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
58	// JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
59	//
60	// public void done() {
61	// isRefreshing = false;
62	// Display.getDefault().asyncExec(new Runnable() {
63	// public void run() {
64	// if (TaskListView.getDefault() != null)
65	// TaskListView.getDefault().refreshAndFocus();
66	// }
67	// });
68	// }
69	//
70	// public boolean isCancelled() {
71	// return monitor.isCanceled();
72	// }
73	//
74	// public void collectIssue(Issue issue) {
75	// int issueId = new Integer(issue.getId());
76	// JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
77	// addHit(hit);
78	// }
79	//
80	// public void start() {
81	//
82	// }
83	// });
84	//
85	// } catch (Exception e) {
86	// isRefreshing = false;
87	// JiraServerFacade.handleConnectionException(e);
88	// return Status.CANCEL_STATUS;
89	// }
90	//
91	// return Status.OK_STATUS;
92	// }
93	//
94	//};
95	//
96	//j.schedule();
97	//
98	//}
99
100	//public String getQueryUrl() {
101	//return super.getQueryUrl();
102	//}
103
104	//public String getPriority() {
105	//return "";
106	//}
107
108	//public String getDescription() {
109	//if (filter.getName() != null) {
110	// return filter.getName();
111	//} else {
112	// return super.getDescription();
113	//}
114	//}
115	//
116	//public void setDescription(String description) {
117	//filter.setDescription(description);
118	//}
119
120	//public boolean isLocal() {
121	//return false;
122	//}
123
124	///** True if the filter is currently downloading hits */
125	//public boolean isRefreshing() {
126	//return isRefreshing;
127	//}
128	//public void setRefreshing(boolean refreshing) {
129	//this.isRefreshing = refreshing;
130	//}