Attachment #66007 for bug #144722

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

Lines 15-21 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/META-INF/MANIFEST.MF (-1 / +2 lines)
15	org.eclipse.mylar.tasks.core,	15	org.eclipse.mylar.tasks.core,
16	org.eclipse.search,	16	org.eclipse.search,
17	com.itsolut.mantis.core,	17	com.itsolut.mantis.core,
18	org.eclipse.jface.text	18	org.eclipse.jface.text,
		19	org.eclipse.mylar
19	Eclipse-LazyStart: true	20	Eclipse-LazyStart: true
20	Export-Package: com.itsolut.mantis.ui,	21	Export-Package: com.itsolut.mantis.ui,
21	com.itsolut.mantis.ui.editor,	22	com.itsolut.mantis.ui.editor,

Lines 17-23 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/MantisQueryWizardPage.java (-1 / +1 lines)
17	import java.util.Set;	17	import java.util.Set;
18		18
19	import org.eclipse.jface.wizard.WizardPage;	19	import org.eclipse.jface.wizard.WizardPage;
20	import org.eclipse.mylar.context.core.MylarStatusHandler;	20	import org.eclipse.mylar.core.MylarStatusHandler;
21	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	21	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
22	import org.eclipse.mylar.tasks.core.TaskRepository;	22	import org.eclipse.mylar.tasks.core.TaskRepository;
23	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	23	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylar.tasks.core.AbstractAttributeFactory;
import org.eclipse.mylar.tasks.core.RepositoryTaskData;
import org.eclipse.mylar.tasks.core.Task;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.swt.SWT;

import com.itsolut.mantis.core.exception.MantisException;
import com.itsolut.mantis.core.model.MantisProject;
import com.itsolut.mantis.core.model.MantisTicket.Key;
import com.itsolut.mantis.core.util.MantisUtils;
import com.itsolut.mantis.ui.MantisUIPlugin;

/**

		}

		MantisOfflineTaskHandler offlineHandler = (MantisOfflineTaskHandler) connector.getTaskDataHandler();
		AbstractAttributeFactory attributeFactory = offlineHandler.getAttributeFactory(taskRepository.getUrl(), taskRepository.getKind(), Task.DEFAULT_TASK_KIND);
		this.taskData = new RepositoryTaskData(attributeFactory, 
				                               MantisCorePlugin.REPOSITORY_KIND,
				                               taskRepository.getUrl(),
				                               TasksUiPlugin.getDefault().getNextNewRepositoryTaskId(), 
				                               Task.DEFAULT_TASK_KIND);
		
		this.taskData.setNew(true);
		
		//default setting
		taskData.setAttributeValue(Key.PROJECT.getKey(), projectCombo.getText());
		
		try {
			MantisOfflineTaskHandler.createDefaultAttributes(taskData.getAttributeFactory(), taskData, client, false);
		} catch (CoreException e) {
			MantisUIPlugin.handleMantisException(e.getCause());
		}

Lines 47-54 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/MantisCustomQueryPage.java (-2 lines)
47	import com.itsolut.mantis.core.model.MantisProjectFilter;	47	import com.itsolut.mantis.core.model.MantisProjectFilter;
48	import com.itsolut.mantis.core.model.MantisSearch;	48	import com.itsolut.mantis.core.model.MantisSearch;
49	import com.itsolut.mantis.core.model.MantisSearchFilter;	49	import com.itsolut.mantis.core.model.MantisSearchFilter;
50	import com.itsolut.mantis.core.model.MantisTicket.Key;
51	import com.itsolut.mantis.core.util.MantisUtils;
52		50
53	/**	51	/**
54	* Mantis search page. Provides a form similar to the one the Bugzilla connector	52	* Mantis search page. Provides a form similar to the one the Bugzilla connector

Lines 30-35 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/MantisRepositorySettingsPage.java (+8 lines)
30	import org.eclipse.jface.dialogs.MessageDialog;	30	import org.eclipse.jface.dialogs.MessageDialog;
31	import org.eclipse.jface.operation.IRunnableWithProgress;	31	import org.eclipse.jface.operation.IRunnableWithProgress;
32	import org.eclipse.mylar.tasks.core.RepositoryTemplate;	32	import org.eclipse.mylar.tasks.core.RepositoryTemplate;
		33	import org.eclipse.mylar.tasks.core.TaskRepository;
33	import org.eclipse.mylar.tasks.ui.AbstractRepositoryConnectorUi;	34	import org.eclipse.mylar.tasks.ui.AbstractRepositoryConnectorUi;
34	import org.eclipse.mylar.tasks.ui.wizards.AbstractRepositorySettingsPage;	35	import org.eclipse.mylar.tasks.ui.wizards.AbstractRepositorySettingsPage;
35	import org.eclipse.swt.SWT;	36	import org.eclipse.swt.SWT;
Lines 116-121 Link Here
116	}	117	}
117	accessTypeCombo.addSelectionListener(new SelectionListener() {	118	accessTypeCombo.addSelectionListener(new SelectionListener() {
118	public void widgetSelected(SelectionEvent e) {	119	public void widgetSelected(SelectionEvent e) {
		120	setMantisVersion(getMantisVersion());
119	getWizard().getContainer().updateButtons();	121	getWizard().getContainer().updateButtons();
120	}	122	}
121		123
Lines 240-243 Link Here
240		242
241	super.getWizard().getContainer().updateButtons();	243	super.getWizard().getContainer().updateButtons();
242	}	244	}
		245
		246	@Override
		247	protected Validator getValidator(TaskRepository repository) {
		248	// TODO Auto-generated method stub
		249	return null;
		250	}
243	}	251	}





import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylar.internal.tasks.ui.TaskListImages;
import org.eclipse.mylar.internal.tasks.ui.TaskListPreferenceConstants;
import org.eclipse.mylar.internal.tasks.ui.TasksUiImages;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiUtil;
import org.eclipse.mylar.tasks.ui.editors.NewTaskEditorInput;

		newTaskPage = new NewMantisTaskPage(taskRepository);
		
		setWindowTitle("New Repository Task");
		setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);
		
		setNeedsProgressMonitor(true);
	}

Lines 12-18 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/NewMantisQueryWizard.java (-2 / +2 lines)
12	package com.itsolut.mantis.ui.wizard;	12	package com.itsolut.mantis.ui.wizard;
13		13
14	import org.eclipse.jface.wizard.Wizard;	14	import org.eclipse.jface.wizard.Wizard;
15	import org.eclipse.mylar.internal.tasks.ui.TaskListImages;	15	import org.eclipse.mylar.internal.tasks.ui.TasksUiImages;
16	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;	16	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
17	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	17	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
18	import org.eclipse.mylar.tasks.core.TaskRepository;	18	import org.eclipse.mylar.tasks.core.TaskRepository;
Lines 34-40 Link Here
34		34
35	setNeedsProgressMonitor(true);	35	setNeedsProgressMonitor(true);
36	setWindowTitle(TITLE);	36	setWindowTitle(TITLE);
37	setDefaultPageImageDescriptor(TaskListImages.BANNER_REPOSITORY);	37	setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);
38	}	38	}
39		39
40	@Override	40	@Override





package com.itsolut.mantis.ui.editor;

import java.util.Collections;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.tasks.ui.editors.AbstractNewRepositoryTaskEditor;
import org.eclipse.mylar.tasks.ui.search.SearchHitCollector;
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.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;

import com.itsolut.mantis.core.IMantisClient;
import com.itsolut.mantis.core.MantisCorePlugin;
import com.itsolut.mantis.core.MantisRepositoryConnector;
import com.itsolut.mantis.core.MantisRepositoryQuery;
import com.itsolut.mantis.core.MantisTask;
import com.itsolut.mantis.core.MantisAttributeFactory.Attribute;
import com.itsolut.mantis.core.exception.InvalidTicketException;
import com.itsolut.mantis.core.model.MantisSearch;
import com.itsolut.mantis.core.model.MantisSearchFilter;
import com.itsolut.mantis.core.model.MantisTicket;
import com.itsolut.mantis.core.model.MantisSearchFilter.CompareOperator;
import com.itsolut.mantis.ui.MantisUIPlugin;

/**
 * @author Steffen Pingel

 */
public class NewMantisTaskEditor extends AbstractNewRepositoryTaskEditor {

	private static final String SUBMIT_JOB_LABEL = "Submitting to Mantis repository";

	protected static final String LABEL_SECTION_STEPS = "Steps To Reproduce";
	protected TextViewer stepsToReproduceViewer;


	}

	@Override
	public void submitToRepository() {
		if (!prepareSubmit()) {
			return;
		}

		final MantisRepositoryConnector connector = (MantisRepositoryConnector) TasksUiPlugin.getRepositoryManager()
				.getRepositoryConnector(repository.getKind());

		updateTask();

		final MantisTicket ticket;
		try {
			ticket = MantisRepositoryConnector.getMantisTicket(repository, getRepositoryTaskData());
		} catch (InvalidTicketException e) {
			MantisUIPlugin.handleMantisException(e);
			submitButton.setEnabled(true);
			showBusy(false);
			return;
		}
		
		//TODO: let user select
		final AbstractTaskContainer category = getCategory();
//		final AbstractTaskContainer category = TasksUiPlugin.getTaskListManager().getTaskList().getRootCategory();
		Job submitJob = new Job(SUBMIT_JOB_LABEL) {
			@Override
			protected IStatus run(IProgressMonitor monitor) {
				try {
					IMantisClient server = connector.getClientManager().getRepository(repository);
					int id = server.createTicket(ticket);

					MantisTask newTask = new MantisTask(AbstractRepositoryTask.getHandle(repository.getUrl(), id),
							MantisRepositoryConnector.getTicketDescription(ticket), true);
					
					if (category != null) {
						TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask, category);
					} else {
						TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
					}

					TasksUiPlugin.getSynchronizationScheduler().synchNow(0, Collections.singletonList(repository));

					return Status.OK_STATUS;
				} catch (Exception e) {
					return MantisCorePlugin.toStatus(e);
				}
			}
		};

		submitJob.addJobChangeListener(getSubmitJobListener());
		submitJob.schedule();
	}

	@Override
	public SearchHitCollector getDuplicateSearchCollector(String searchString) {
		MantisSearchFilter filter = new MantisSearchFilter("description");
		filter.setOperator(CompareOperator.CONTAINS);

				repository, query);
		return collector;
	}

	@Override
	protected void handleSubmitError(final IJobChangeEvent event) {
		MantisUIPlugin.handleMantisException(event.getJob().getResult());
		
		if (!isDisposed() && !submitButton.isDisposed()) {
			submitButton.setEnabled(true);
			showBusy(false);
		}
	}

	@Override
	protected String getPluginId() {
		return MantisUIPlugin.PLUGIN_ID;
	}

	@Override
	protected void createAttachmentLayout(Composite composite) {
		FormToolkit toolkit = this.getManagedForm().getToolkit();
		Section section = createSection(composite, LABEL_SECTION_STEPS);
		section.setExpanded(false);

		Composite stepsToReproduceComposite = toolkit.createComposite(section);
		GridLayout descriptionLayout = new GridLayout();

		stepsToReproduceComposite.setLayout(descriptionLayout);
		GridData stepsToReproduceData = new GridData(GridData.FILL_BOTH);
		stepsToReproduceData.grabExcessVerticalSpace = true;
		stepsToReproduceComposite.setLayoutData(stepsToReproduceData);
		section.setClient(stepsToReproduceComposite);

		stepsToReproduceViewer = addTextEditor(repository, stepsToReproduceComposite,
				getRepositoryTaskData().getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey()), true, SWT.FLAT | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		stepsToReproduceViewer.setEditable(true);

		GridData descriptionTextData = new GridData(GridData.FILL_BOTH);
		stepsToReproduceViewer.getControl().setLayoutData(descriptionTextData);
		stepsToReproduceViewer.getControl().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
		stepsToReproduceViewer.getTextWidget().addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				String changed = stepsToReproduceViewer.getTextWidget().getText();
				String original = getRepositoryTaskData().getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey());
				if (original==null || !(original.equals(changed))) {
					getRepositoryTaskData().getAttribute(Attribute.STEPS_TO_REPRODUCE.getMantisKey()).setValue(changed);
					markDirty(true);
				}
				validateInput();
			}
		});

		toolkit.paintBordersFor(stepsToReproduceComposite);
		
		////////////////
		Section sectionAddtional = createSection(composite, LABEL_SECTION_ADDITIONAL);
		sectionAddtional.setExpanded(false);

		Composite additionalComposite = toolkit.createComposite(sectionAddtional);
		GridLayout additionalLayout = new GridLayout();

		additionalComposite.setLayout(additionalLayout);
		GridData additionalData = new GridData(GridData.FILL_BOTH);
		additionalData.grabExcessVerticalSpace = true;
		additionalComposite.setLayoutData(additionalData);
		sectionAddtional.setClient(additionalComposite);

		additionalViewer = addTextEditor(repository, additionalComposite,
				getRepositoryTaskData().getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey()), true, SWT.FLAT | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		additionalViewer.setEditable(true);

		GridData additionalTextData = new GridData(GridData.FILL_BOTH);
		additionalViewer.getControl().setLayoutData(additionalTextData);
		additionalViewer.getControl().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
		additionalViewer.getTextWidget().addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				String changed = additionalViewer.getTextWidget().getText();
				String original = getRepositoryTaskData().getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey());
				if (original==null || !(original.equals(changed))) {
					getRepositoryTaskData().getAttribute(Attribute.ADDITIONAL_INFO.getMantisKey()).setValue(changed);
					markDirty(true);
				}
				validateInput();
			}
		});

		toolkit.paintBordersFor(additionalComposite);
		///////////////////
		
		super.createAttachmentLayout(composite);
	}
}





package com.itsolut.mantis.ui.editor;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.mylar.context.core.MylarStatusHandler;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.tasks.ui.editors.AbstractRepositoryTaskEditor;
import org.eclipse.mylar.tasks.ui.editors.AbstractTaskEditorInput;
import org.eclipse.mylar.tasks.ui.editors.RepositoryTaskEditorInput;
import org.eclipse.mylar.tasks.ui.editors.RepositoryTaskOutlineNode;
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.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.progress.IProgressService;

import com.itsolut.mantis.core.IMantisClient;
import com.itsolut.mantis.core.MantisCorePlugin;
import com.itsolut.mantis.core.MantisRepositoryConnector;
import com.itsolut.mantis.core.MantisAttributeFactory.Attribute;
import com.itsolut.mantis.core.exception.InvalidTicketException;
import com.itsolut.mantis.core.model.MantisTicket;
import com.itsolut.mantis.ui.MantisUIPlugin;

/**
 * @author Steffen Pingel

 */
public class MantisTaskEditor extends AbstractRepositoryTaskEditor {

	private static final String SUBMIT_JOB_LABEL = "Submitting to Mantis Repository";

	protected static final String LABEL_SECTION_STEPS = "Steps To Reproduce";
	protected TextViewer stepsToReproduceViewer;


	}

	@Override
	public void init(IEditorSite site, IEditorInput input) {
		if (!(input instanceof RepositoryTaskEditorInput))
			return;

		editorInput = (AbstractTaskEditorInput) input;
		repository = editorInput.getRepository();
		connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
				repository.getKind());

		setSite(site);
		setInput(input);

		taskOutlineModel = RepositoryTaskOutlineNode.parseBugReport(editorInput.getTaskData());

		isDirty = false;
		updateEditorTitle();
	}

	@Override
	public void submitToRepository() {
		if (isDirty()) {
			this.doSave(new NullProgressMonitor());
		}
		updateTask();
		submitButton.setEnabled(false);
		showBusy(true);

		final MantisTicket ticket;
		try {
			ticket = MantisRepositoryConnector.getMantisTicket(repository, getRepositoryTaskData());
		} catch (InvalidTicketException e) {
			MantisUIPlugin.handleMantisException(e);
			return;
		}
		final String comment = getNewCommentText();
		final AbstractRepositoryTask task = (AbstractRepositoryTask) TasksUiPlugin.getTaskListManager().getTaskList()
				.getTask(AbstractRepositoryTask.getHandle(repository.getUrl(), getRepositoryTaskData().getId()));
		final boolean attachContext = getAttachContext();

		JobChangeAdapter listener = new JobChangeAdapter() {
			@Override
			public void done(final IJobChangeEvent event) {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						if (event.getJob().getResult().isOK()) {
							if (attachContext) {
								attachContext();
							}
							close();
						}
					}
				});
			}
		};

		Job submitJob = new Job(SUBMIT_JOB_LABEL) {

			@Override
			protected IStatus run(IProgressMonitor monitor) {
				try {
					IMantisClient server = ((MantisRepositoryConnector) connector).getClientManager().getRepository(repository);
					server.updateTicket(ticket, comment);
					if (task != null) {
						// XXX: HACK TO AVOID OVERWRITE WARNING
						task.setTaskData(null);
						TasksUiPlugin.getSynchronizationManager().synchronize(connector, task, true, null);
					}
					return Status.OK_STATUS;
				} catch (final Exception e) {
					PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
						public void run() {
							if (!isDisposed() && !submitButton.isDisposed()) {
								MantisUIPlugin.handleMantisException(e);
								// MantisUiPlugin.handleMantisException(event.getResult());
								submitButton.setEnabled(true);
								MantisTaskEditor.this.showBusy(false);
							}
						}
					});
					return Status.CANCEL_STATUS;
				}
			}

		};

		submitJob.addJobChangeListener(listener);
		submitJob.schedule();

	}

	@Override
	protected void validateInput() {
	}

	private void attachContext() {
		String handle = AbstractRepositoryTask.getHandle(repository.getUrl(), getRepositoryTaskData().getId());
		final AbstractRepositoryTask modifiedTask = (AbstractRepositoryTask) TasksUiPlugin.getTaskListManager()
				.getTaskList().getTask(handle);

		IProgressService ps = PlatformUI.getWorkbench().getProgressService();
		try {
			ps.busyCursorWhile(new IRunnableWithProgress() {
				public void run(IProgressMonitor pm) {
					try {
						connector.attachContext(repository, modifiedTask, "");
					} catch (Exception e) {
						MylarStatusHandler.fail(e, "Failed to attach task context.\n\n" + e.getMessage(), true);
					}
				}
			});
		} catch (InvocationTargetException e) {
			MylarStatusHandler.fail(e.getCause(), "Failed to attach task context.\n\n" + e.getMessage(), true);
		} catch (InterruptedException ignore) {
		}
	}

	@Override
	protected String getPluginId() {
		return MantisUIPlugin.PLUGIN_ID;
	}

	@Override
	protected void createAttachmentLayout(Composite composite) {
		FormToolkit toolkit = this.getManagedForm().getToolkit();
		Section section = createSection(composite, LABEL_SECTION_STEPS);

		section.setClient(stepsToReproduceComposite);

		stepsToReproduceViewer = addTextEditor(repository, stepsToReproduceComposite,
				taskData.getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey()), true, SWT.FLAT | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		stepsToReproduceViewer.setEditable(true);

		GridData descriptionTextData = new GridData(GridData.FILL_BOTH);

		stepsToReproduceViewer.getTextWidget().addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				String changed = stepsToReproduceViewer.getTextWidget().getText();
				String original = taskData.getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey());
				if (original==null || !(original.equals(changed))) {
					taskData.getAttribute(Attribute.STEPS_TO_REPRODUCE.getMantisKey()).setValue(changed);
					markDirty(true);
				}
				validateInput();

		sectionAddtional.setClient(additionalComposite);

		additionalViewer = addTextEditor(repository, additionalComposite,
				taskData.getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey()), true, SWT.FLAT | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		additionalViewer.setEditable(true);

		GridData additionalTextData = new GridData(GridData.FILL_BOTH);

		additionalViewer.getTextWidget().addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				String changed = additionalViewer.getTextWidget().getText();
				String original = taskData.getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey());
				if (original==null || !(original.equals(changed))) {
					taskData.getAttribute(Attribute.ADDITIONAL_INFO.getMantisKey()).setValue(changed);
					markDirty(true);
				}
				validateInput();

		
		super.createAttachmentLayout(composite);
	}
	
	@Override
	protected void addCCList(Composite attributesComposite) {
		// TODO Auto-generated method stub
		//super.addCCList(attributesComposite);
	}
	
	@Override
	protected void addSelfToCC(Composite composite) {
		// TODO Auto-generated method stub
		//super.addSelfToCC(composite);
	}
}




 *******************************************************************************/
package com.itsolut.mantis.ui.editor;

import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;

	}

	public IEditorPart createEditor(TaskEditor parentEditor, IEditorInput editorInput) {
		if (editorInput instanceof RepositoryTaskEditorInput) {
			RepositoryTaskEditorInput taskInput = (RepositoryTaskEditorInput) editorInput;
			if (taskInput.getTaskData().isNew()) {
				return new NewMantisTaskEditor(parentEditor);
			} else {
				return new MantisTaskEditor(parentEditor);
			}
		} else if (editorInput instanceof TaskEditorInput) {
			return new MantisTaskEditor(parentEditor);
		}
			return new NewMantisTaskEditor(parentEditor);
		} 
		return null;
	}


		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(MantisCorePlugin.REPOSITORY_KIND,
				tracTask.getRepositoryUrl());
		try {
			return new RepositoryTaskEditorInput(repository, tracTask.getHandleIdentifier(), tracTask.getTaskUrl(), tracTask.getTaskId());
		} catch (Exception e) {
			MylarStatusHandler.fail(e, "Could not create Mantis editor input", true);
		}

Lines 13-19 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/MantisUIPlugin.java (-1 / +1 lines)
13		13
14	import org.eclipse.core.runtime.IStatus;	14	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.jface.dialogs.ErrorDialog;	15	import org.eclipse.jface.dialogs.ErrorDialog;
16	import org.eclipse.mylar.context.core.MylarStatusHandler;	16	import org.eclipse.mylar.core.MylarStatusHandler;
17	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	17	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
18	import org.eclipse.ui.plugin.AbstractUIPlugin;	18	import org.eclipse.ui.plugin.AbstractUIPlugin;
19	import org.osgi.framework.BundleContext;	19	import org.osgi.framework.BundleContext;




	}

	@Override
	public boolean openRepositoryTask(String repositoryUrl, String id) {
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		String ticketUrl = repositoryUrl + IMantisClient.TICKET_URL + id;
		OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(MantisCorePlugin.REPOSITORY_KIND, repositoryUrl, id, ticketUrl, page);
		job.schedule();
		return true;
	}
	
}





package com.itsolut.mantis.ui;

import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.tasks.core.AbstractQueryHit;
import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylar.tasks.core.AbstractTaskContainer;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.itsolut.mantis.core.MantisQueryHit;
import com.itsolut.mantis.core.MantisRepositoryQuery;

		return KEY_TRAC_TASK;
	}

	//query related methods
	
	@Override
	public ITask createTask(String repositoryUrl, String taskId, String summary,
			Element element, TaskList taskList, AbstractTaskContainer category,
			ITask parent) throws TaskExternalizationException {
		return new MantisTask(repositoryUrl, taskId, summary, false);
		String handle;
		String label;
		if (element.hasAttribute(KEY_HANDLE)) {
			handle = element.getAttribute(KEY_HANDLE);
		} else {
			throw new TaskExternalizationException("Handle not stored for task");
		}
		if (element.hasAttribute(KEY_LABEL)) {
			label = element.getAttribute(KEY_LABEL);
		} else {
			throw new TaskExternalizationException("Description not stored for task");
		}

		MantisTask task = new MantisTask(handle, label, false);
		readTaskInfo(task, taskList, element, parent, category);
		return task;
	}

	// query related methods
	
	@Override
	public boolean canCreateElementFor(AbstractQueryHit queryHit) {

			throw new TaskExternalizationException("Description not stored for task");
		}

		return new MantisRepositoryQuery(repositoryUrl, queryUrl, label, taskList);

		NodeList list = node.getChildNodes();
		for (int i = 0; i < list.getLength(); i++) {
			Node child = list.item(i);
			try {
				readQueryHit(child, taskList, query);
			} catch (TaskExternalizationException e) {
				MylarStatusHandler.log(e, e.getMessage());
			}
		}
		return query;
	}
	
	@Override
	public AbstractQueryHit createQueryHit(String repositoryUrl, String taskId,
			String summary, Element element, TaskList taskList,
			AbstractRepositoryQuery query) throws TaskExternalizationException {
		
		MantisQueryHit hit = new MantisQueryHit(taskList, repositoryUrl, summary, taskId);
		
		// TODO: move to DelegationTaskExternalizer
		} else {
			throw new TaskExternalizationException("Handle not stored for bug report");
		}

		MantisQueryHit hit = new MantisQueryHit(taskList, handle);
		// TODO move to DelegationTaskExternalizer
		if (element.hasAttribute(KEY_COMPLETE)
				&& element.getAttribute(KEY_COMPLETE).compareTo(VAL_TRUE) == 0) {
			hit.setCompleted(true);
		} else {
			hit.setCompleted(false);
		}
		
		return hit;
	}

}

Return to bug 144722

Lines 79-90 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/MantisRepositoryUi.java (-4 / +3 lines)
79	}	79	}
80		80
81	@Override	81	@Override
82	public boolean openRemoteTask(String repositoryUrl, String idString) {	82	public boolean openRepositoryTask(String repositoryUrl, String id) {
83	IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();	83	IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
84	String ticketUrl = repositoryUrl + IMantisClient.TICKET_URL + idString;	84	String ticketUrl = repositoryUrl + IMantisClient.TICKET_URL + id;
85	OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(MantisCorePlugin.REPOSITORY_KIND, repositoryUrl, idString, ticketUrl, page);	85	OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(MantisCorePlugin.REPOSITORY_KIND, repositoryUrl, id, ticketUrl, page);
86	job.schedule();	86	job.schedule();
87	return true;	87	return true;
88	}	88	}
89
90	}	89	}

Lines 11-17 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/MantisTaskExternalizer.java (-52 / +18 lines)
11		11
12	package com.itsolut.mantis.ui;	12	package com.itsolut.mantis.ui;
13		13
14	import org.eclipse.mylar.context.core.MylarStatusHandler;	14	import org.eclipse.mylar.core.MylarStatusHandler;
15	import org.eclipse.mylar.tasks.core.AbstractQueryHit;	15	import org.eclipse.mylar.tasks.core.AbstractQueryHit;
16	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	16	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
17	import org.eclipse.mylar.tasks.core.AbstractTaskContainer;	17	import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
Lines 23-29 Link Here
23	import org.w3c.dom.Document;	23	import org.w3c.dom.Document;
24	import org.w3c.dom.Element;	24	import org.w3c.dom.Element;
25	import org.w3c.dom.Node;	25	import org.w3c.dom.Node;
26	import org.w3c.dom.NodeList;
27		26
28	import com.itsolut.mantis.core.MantisQueryHit;	27	import com.itsolut.mantis.core.MantisQueryHit;
29	import com.itsolut.mantis.core.MantisRepositoryQuery;	28	import com.itsolut.mantis.core.MantisRepositoryQuery;
Lines 68-97 Link Here
68	return KEY_TRAC_TASK;	67	return KEY_TRAC_TASK;
69	}	68	}
70		69
		70	//query related methods
		71
71	@Override	72	@Override
72	public ITask readTask(Node node, TaskList taskList, AbstractTaskContainer category, ITask parent)	73	public ITask createTask(String repositoryUrl, String taskId, String summary,
73	throws TaskExternalizationException {	74	Element element, TaskList taskList, AbstractTaskContainer category,
74		75	ITask parent) throws TaskExternalizationException {
75	Element element = (Element) node;	76	return new MantisTask(repositoryUrl, taskId, summary, false);
76	String handle;
77	String label;
78	if (element.hasAttribute(KEY_HANDLE)) {
79	handle = element.getAttribute(KEY_HANDLE);
80	} else {
81	throw new TaskExternalizationException("Handle not stored for task");
82	}
83	if (element.hasAttribute(KEY_LABEL)) {
84	label = element.getAttribute(KEY_LABEL);
85	} else {
86	throw new TaskExternalizationException("Description not stored for task");
87	}
88
89	MantisTask task = new MantisTask(handle, label, false);
90	readTaskInfo(task, taskList, element, parent, category);
91	return task;
92	}	77	}
93
94	// query related methods
95		78
96	@Override	79	@Override
97	public boolean canCreateElementFor(AbstractQueryHit queryHit) {	80	public boolean canCreateElementFor(AbstractQueryHit queryHit) {
Lines 176-216 Link Here
176	throw new TaskExternalizationException("Description not stored for task");	159	throw new TaskExternalizationException("Description not stored for task");
177	}	160	}
178		161
179	MantisRepositoryQuery query = new MantisRepositoryQuery(repositoryUrl, queryUrl, label, taskList);	162	return new MantisRepositoryQuery(repositoryUrl, queryUrl, label, taskList);
180
181	NodeList list = node.getChildNodes();
182	for (int i = 0; i < list.getLength(); i++) {
183	Node child = list.item(i);
184	try {
185	readQueryHit(child, taskList, query);
186	} catch (TaskExternalizationException e) {
187	MylarStatusHandler.log(e, e.getMessage());
188	}
189	}
190	return query;
191	}	163	}
192		164
193	@Override	165	@Override
194	public void readQueryHit(Node node, TaskList taskList, AbstractRepositoryQuery query)	166	public AbstractQueryHit createQueryHit(String repositoryUrl, String taskId,
195	throws TaskExternalizationException {	167	String summary, Element element, TaskList taskList,
196	Element element = (Element) node;	168	AbstractRepositoryQuery query) throws TaskExternalizationException {
197		169
198	String handle;	170	MantisQueryHit hit = new MantisQueryHit(taskList, repositoryUrl, summary, taskId);
199	if (element.hasAttribute(KEY_HANDLE)) {	171
200	handle = element.getAttribute(KEY_HANDLE);	172	// TODO: move to DelegationTaskExternalizer
201	} else {
202	throw new TaskExternalizationException("Handle not stored for bug report");
203	}
204
205	MantisQueryHit hit = new MantisQueryHit(taskList, handle);
206	// TODO move to DelegationTaskExternalizer
207	if (element.hasAttribute(KEY_COMPLETE)	173	if (element.hasAttribute(KEY_COMPLETE)
208	&& element.getAttribute(KEY_COMPLETE).compareTo(VAL_TRUE) == 0) {	174	&& element.getAttribute(KEY_COMPLETE).compareTo(VAL_TRUE) == 0) {
209	hit.setCompleted(true);	175	hit.setCompleted(true);
210	} else {	176	} else {
211	hit.setCompleted(false);	177	hit.setCompleted(false);
212	}	178	}
213	readQueryHitInfo(hit, taskList, query, element);	179
		180	return hit;
214	}	181	}
215
216	}	182	}

Lines 28-34 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/NewMantisTaskPage.java (-5 / +9 lines)
28	import org.eclipse.core.runtime.IProgressMonitor;	28	import org.eclipse.core.runtime.IProgressMonitor;
29	import org.eclipse.jface.operation.IRunnableWithProgress;	29	import org.eclipse.jface.operation.IRunnableWithProgress;
30	import org.eclipse.jface.wizard.WizardPage;	30	import org.eclipse.jface.wizard.WizardPage;
		31	import org.eclipse.mylar.tasks.core.AbstractAttributeFactory;
31	import org.eclipse.mylar.tasks.core.RepositoryTaskData;	32	import org.eclipse.mylar.tasks.core.RepositoryTaskData;
		33	import org.eclipse.mylar.tasks.core.Task;
32	import org.eclipse.mylar.tasks.core.TaskRepository;	34	import org.eclipse.mylar.tasks.core.TaskRepository;
33	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	35	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
34	import org.eclipse.swt.SWT;	36	import org.eclipse.swt.SWT;
Lines 44-50 Link Here
44	import com.itsolut.mantis.core.exception.MantisException;	46	import com.itsolut.mantis.core.exception.MantisException;
45	import com.itsolut.mantis.core.model.MantisProject;	47	import com.itsolut.mantis.core.model.MantisProject;
46	import com.itsolut.mantis.core.model.MantisTicket.Key;	48	import com.itsolut.mantis.core.model.MantisTicket.Key;
47	import com.itsolut.mantis.core.util.MantisUtils;
48	import com.itsolut.mantis.ui.MantisUIPlugin;	49	import com.itsolut.mantis.ui.MantisUIPlugin;
49		50
50	/**	51	/**
Lines 159-175 Link Here
159	}	160	}
160		161
161	MantisOfflineTaskHandler offlineHandler = (MantisOfflineTaskHandler) connector.getTaskDataHandler();	162	MantisOfflineTaskHandler offlineHandler = (MantisOfflineTaskHandler) connector.getTaskDataHandler();
162		163	AbstractAttributeFactory attributeFactory = offlineHandler.getAttributeFactory(taskRepository.getUrl(), taskRepository.getKind(), Task.DEFAULT_TASK_KIND);
163	this.taskData = new RepositoryTaskData(offlineHandler.getAttributeFactory(),	164	this.taskData = new RepositoryTaskData(attributeFactory,
164	MantisCorePlugin.REPOSITORY_KIND,	165	MantisCorePlugin.REPOSITORY_KIND,
165	taskRepository.getUrl(),	166	taskRepository.getUrl(),
166	TasksUiPlugin.getDefault().getNextNewRepositoryTaskId());	167	TasksUiPlugin.getDefault().getNextNewRepositoryTaskId(),
		168	Task.DEFAULT_TASK_KIND);
167		169
		170	this.taskData.setNew(true);
		171
168	//default setting	172	//default setting
169	taskData.setAttributeValue(Key.PROJECT.getKey(), projectCombo.getText());	173	taskData.setAttributeValue(Key.PROJECT.getKey(), projectCombo.getText());
170		174
171	try {	175	try {
172	MantisOfflineTaskHandler.createDefaultAttributes(offlineHandler.getAttributeFactory(), taskData, client, false);	176	MantisOfflineTaskHandler.createDefaultAttributes(taskData.getAttributeFactory(), taskData, client, false);
173	} catch (CoreException e) {	177	} catch (CoreException e) {
174	MantisUIPlugin.handleMantisException(e.getCause());	178	MantisUIPlugin.handleMantisException(e.getCause());
175	}	179	}

Lines 13-20 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/wizard/NewMantisTaskWizard.java (-2 / +2 lines)
13		13
14	import org.eclipse.jface.viewers.IStructuredSelection;	14	import org.eclipse.jface.viewers.IStructuredSelection;
15	import org.eclipse.jface.wizard.Wizard;	15	import org.eclipse.jface.wizard.Wizard;
16	import org.eclipse.mylar.internal.tasks.ui.TaskListImages;
17	import org.eclipse.mylar.internal.tasks.ui.TaskListPreferenceConstants;	16	import org.eclipse.mylar.internal.tasks.ui.TaskListPreferenceConstants;
		17	import org.eclipse.mylar.internal.tasks.ui.TasksUiImages;
18	import org.eclipse.mylar.tasks.core.TaskRepository;	18	import org.eclipse.mylar.tasks.core.TaskRepository;
19	import org.eclipse.mylar.tasks.ui.TasksUiUtil;	19	import org.eclipse.mylar.tasks.ui.TasksUiUtil;
20	import org.eclipse.mylar.tasks.ui.editors.NewTaskEditorInput;	20	import org.eclipse.mylar.tasks.ui.editors.NewTaskEditorInput;
Lines 40-46 Link Here
40	newTaskPage = new NewMantisTaskPage(taskRepository);	40	newTaskPage = new NewMantisTaskPage(taskRepository);
41		41
42	setWindowTitle("New Repository Task");	42	setWindowTitle("New Repository Task");
43	setDefaultPageImageDescriptor(TaskListImages.BANNER_REPOSITORY);	43	setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);
44		44
45	setNeedsProgressMonitor(true);	45	setNeedsProgressMonitor(true);
46	}	46	}

Lines 18-58 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/editor/NewMantisTaskEditor.java (-168 lines)
18		18
19	package com.itsolut.mantis.ui.editor;	19	package com.itsolut.mantis.ui.editor;
20		20
21	import java.util.Collections;
22
23	import org.eclipse.core.runtime.IProgressMonitor;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.core.runtime.jobs.IJobChangeEvent;
27	import org.eclipse.core.runtime.jobs.Job;
28	import org.eclipse.jface.text.TextViewer;	21	import org.eclipse.jface.text.TextViewer;
29	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
30	import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
31	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	22	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
32	import org.eclipse.mylar.tasks.ui.editors.AbstractNewRepositoryTaskEditor;	23	import org.eclipse.mylar.tasks.ui.editors.AbstractNewRepositoryTaskEditor;
33	import org.eclipse.mylar.tasks.ui.search.SearchHitCollector;	24	import org.eclipse.mylar.tasks.ui.search.SearchHitCollector;
34	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.events.ModifyEvent;
36	import org.eclipse.swt.events.ModifyListener;
37	import org.eclipse.swt.layout.GridData;
38	import org.eclipse.swt.layout.GridLayout;
39	import org.eclipse.swt.widgets.Composite;
40	import org.eclipse.ui.forms.editor.FormEditor;	25	import org.eclipse.ui.forms.editor.FormEditor;
41	import org.eclipse.ui.forms.widgets.FormToolkit;
42	import org.eclipse.ui.forms.widgets.Section;
43		26
44	import com.itsolut.mantis.core.IMantisClient;	27	import com.itsolut.mantis.core.IMantisClient;
45	import com.itsolut.mantis.core.MantisCorePlugin;
46	import com.itsolut.mantis.core.MantisRepositoryConnector;
47	import com.itsolut.mantis.core.MantisRepositoryQuery;	28	import com.itsolut.mantis.core.MantisRepositoryQuery;
48	import com.itsolut.mantis.core.MantisTask;
49	import com.itsolut.mantis.core.MantisAttributeFactory.Attribute;
50	import com.itsolut.mantis.core.exception.InvalidTicketException;
51	import com.itsolut.mantis.core.model.MantisSearch;	29	import com.itsolut.mantis.core.model.MantisSearch;
52	import com.itsolut.mantis.core.model.MantisSearchFilter;	30	import com.itsolut.mantis.core.model.MantisSearchFilter;
53	import com.itsolut.mantis.core.model.MantisTicket;
54	import com.itsolut.mantis.core.model.MantisSearchFilter.CompareOperator;	31	import com.itsolut.mantis.core.model.MantisSearchFilter.CompareOperator;
55	import com.itsolut.mantis.ui.MantisUIPlugin;
56		32
57	/**	33	/**
58	* @author Steffen Pingel	34	* @author Steffen Pingel
Lines 60-67 Link Here
60	*/	36	*/
61	public class NewMantisTaskEditor extends AbstractNewRepositoryTaskEditor {	37	public class NewMantisTaskEditor extends AbstractNewRepositoryTaskEditor {
62		38
63	private static final String SUBMIT_JOB_LABEL = "Submitting to Mantis repository";
64
65	protected static final String LABEL_SECTION_STEPS = "Steps To Reproduce";	39	protected static final String LABEL_SECTION_STEPS = "Steps To Reproduce";
66	protected TextViewer stepsToReproduceViewer;	40	protected TextViewer stepsToReproduceViewer;
67		41
Lines 73-131 Link Here
73	}	47	}
74		48
75	@Override	49	@Override
76	public void submitToRepository() {
77	if (!prepareSubmit()) {
78	return;
79	}
80
81	final MantisRepositoryConnector connector = (MantisRepositoryConnector) TasksUiPlugin.getRepositoryManager()
82	.getRepositoryConnector(repository.getKind());
83
84	updateTask();
85
86	final MantisTicket ticket;
87	try {
88	ticket = MantisRepositoryConnector.getMantisTicket(repository, getRepositoryTaskData());
89	} catch (InvalidTicketException e) {
90	MantisUIPlugin.handleMantisException(e);
91	submitButton.setEnabled(true);
92	showBusy(false);
93	return;
94	}
95
96	//TODO: let user select
97	final AbstractTaskContainer category = getCategory();
98	// final AbstractTaskContainer category = TasksUiPlugin.getTaskListManager().getTaskList().getRootCategory();
99	Job submitJob = new Job(SUBMIT_JOB_LABEL) {
100	@Override
101	protected IStatus run(IProgressMonitor monitor) {
102	try {
103	IMantisClient server = connector.getClientManager().getRepository(repository);
104	int id = server.createTicket(ticket);
105
106	MantisTask newTask = new MantisTask(AbstractRepositoryTask.getHandle(repository.getUrl(), id),
107	MantisRepositoryConnector.getTicketDescription(ticket), true);
108
109	if (category != null) {
110	TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask, category);
111	} else {
112	TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
113	}
114
115	TasksUiPlugin.getSynchronizationScheduler().synchNow(0, Collections.singletonList(repository));
116
117	return Status.OK_STATUS;
118	} catch (Exception e) {
119	return MantisCorePlugin.toStatus(e);
120	}
121	}
122	};
123
124	submitJob.addJobChangeListener(getSubmitJobListener());
125	submitJob.schedule();
126	}
127
128	@Override
129	public SearchHitCollector getDuplicateSearchCollector(String searchString) {	50	public SearchHitCollector getDuplicateSearchCollector(String searchString) {
130	MantisSearchFilter filter = new MantisSearchFilter("description");	51	MantisSearchFilter filter = new MantisSearchFilter("description");
131	filter.setOperator(CompareOperator.CONTAINS);	52	filter.setOperator(CompareOperator.CONTAINS);
Lines 147-239 Link Here
147	repository, query);	68	repository, query);
148	return collector;	69	return collector;
149	}	70	}
150
151	@Override
152	protected void handleSubmitError(final IJobChangeEvent event) {
153	MantisUIPlugin.handleMantisException(event.getJob().getResult());
154
155	if (!isDisposed() && !submitButton.isDisposed()) {
156	submitButton.setEnabled(true);
157	showBusy(false);
158	}
159	}
160
161	@Override
162	protected String getPluginId() {
163	return MantisUIPlugin.PLUGIN_ID;
164	}
165
166	@Override
167	protected void createAttachmentLayout(Composite composite) {
168	FormToolkit toolkit = this.getManagedForm().getToolkit();
169	Section section = createSection(composite, LABEL_SECTION_STEPS);
170	section.setExpanded(false);
171
172	Composite stepsToReproduceComposite = toolkit.createComposite(section);
173	GridLayout descriptionLayout = new GridLayout();
174
175	stepsToReproduceComposite.setLayout(descriptionLayout);
176	GridData stepsToReproduceData = new GridData(GridData.FILL_BOTH);
177	stepsToReproduceData.grabExcessVerticalSpace = true;
178	stepsToReproduceComposite.setLayoutData(stepsToReproduceData);
179	section.setClient(stepsToReproduceComposite);
180
181	stepsToReproduceViewer = addTextEditor(repository, stepsToReproduceComposite,
182	getRepositoryTaskData().getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey()), true, SWT.FLAT \| SWT.MULTI \| SWT.WRAP \| SWT.V_SCROLL);
183	stepsToReproduceViewer.setEditable(true);
184
185	GridData descriptionTextData = new GridData(GridData.FILL_BOTH);
186	stepsToReproduceViewer.getControl().setLayoutData(descriptionTextData);
187	stepsToReproduceViewer.getControl().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
188	stepsToReproduceViewer.getTextWidget().addModifyListener(new ModifyListener() {
189	public void modifyText(ModifyEvent e) {
190	String changed = stepsToReproduceViewer.getTextWidget().getText();
191	String original = getRepositoryTaskData().getAttributeValue(Attribute.STEPS_TO_REPRODUCE.getMantisKey());
192	if (original==null \|\| !(original.equals(changed))) {
193	getRepositoryTaskData().getAttribute(Attribute.STEPS_TO_REPRODUCE.getMantisKey()).setValue(changed);
194	markDirty(true);
195	}
196	validateInput();
197	}
198	});
199
200	toolkit.paintBordersFor(stepsToReproduceComposite);
201
202	////////////////
203	Section sectionAddtional = createSection(composite, LABEL_SECTION_ADDITIONAL);
204	sectionAddtional.setExpanded(false);
205
206	Composite additionalComposite = toolkit.createComposite(sectionAddtional);
207	GridLayout additionalLayout = new GridLayout();
208
209	additionalComposite.setLayout(additionalLayout);
210	GridData additionalData = new GridData(GridData.FILL_BOTH);
211	additionalData.grabExcessVerticalSpace = true;
212	additionalComposite.setLayoutData(additionalData);
213	sectionAddtional.setClient(additionalComposite);
214
215	additionalViewer = addTextEditor(repository, additionalComposite,
216	getRepositoryTaskData().getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey()), true, SWT.FLAT \| SWT.MULTI \| SWT.WRAP \| SWT.V_SCROLL);
217	additionalViewer.setEditable(true);
218
219	GridData additionalTextData = new GridData(GridData.FILL_BOTH);
220	additionalViewer.getControl().setLayoutData(additionalTextData);
221	additionalViewer.getControl().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
222	additionalViewer.getTextWidget().addModifyListener(new ModifyListener() {
223	public void modifyText(ModifyEvent e) {
224	String changed = additionalViewer.getTextWidget().getText();
225	String original = getRepositoryTaskData().getAttributeValue(Attribute.ADDITIONAL_INFO.getMantisKey());
226	if (original==null \|\| !(original.equals(changed))) {
227	getRepositoryTaskData().getAttribute(Attribute.ADDITIONAL_INFO.getMantisKey()).setValue(changed);
228	markDirty(true);
229	}
230	validateInput();
231	}
232	});
233
234	toolkit.paintBordersFor(additionalComposite);
235	///////////////////
236
237	super.createAttachmentLayout(composite);
238	}
239	}	71	}

Lines 7-13 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.ui/src/com/itsolut/mantis/ui/editor/MantisTaskEditorFactory.java (-6 / +11 lines)
7	*******************************************************************************/	7	*******************************************************************************/
8	package com.itsolut.mantis.ui.editor;	8	package com.itsolut.mantis.ui.editor;
9		9
10	import org.eclipse.mylar.context.core.MylarStatusHandler;	10	import org.eclipse.mylar.core.MylarStatusHandler;
11	import org.eclipse.mylar.tasks.core.ITask;	11	import org.eclipse.mylar.tasks.core.ITask;
12	import org.eclipse.mylar.tasks.core.TaskRepository;	12	import org.eclipse.mylar.tasks.core.TaskRepository;
13	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	13	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
Lines 51-61 Link Here
51	}	51	}
52		52
53	public IEditorPart createEditor(TaskEditor parentEditor, IEditorInput editorInput) {	53	public IEditorPart createEditor(TaskEditor parentEditor, IEditorInput editorInput) {
54	if (editorInput instanceof RepositoryTaskEditorInput \|\| editorInput instanceof TaskEditorInput) {	54	if (editorInput instanceof RepositoryTaskEditorInput) {
		55	RepositoryTaskEditorInput taskInput = (RepositoryTaskEditorInput) editorInput;
		56	if (taskInput.getTaskData().isNew()) {
		57	return new NewMantisTaskEditor(parentEditor);
		58	} else {
		59	return new MantisTaskEditor(parentEditor);
		60	}
		61	} else if (editorInput instanceof TaskEditorInput) {
55	return new MantisTaskEditor(parentEditor);	62	return new MantisTaskEditor(parentEditor);
56	} else if (editorInput instanceof NewTaskEditorInput) {	63	}
57	return new NewMantisTaskEditor(parentEditor);
58	}
59	return null;	64	return null;
60	}	65	}
61		66
Lines 64-70 Link Here
64	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(MantisCorePlugin.REPOSITORY_KIND,	69	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(MantisCorePlugin.REPOSITORY_KIND,
65	tracTask.getRepositoryUrl());	70	tracTask.getRepositoryUrl());
66	try {	71	try {
67	return new RepositoryTaskEditorInput(repository, tracTask.getHandleIdentifier(), tracTask.getUrl());	72	return new RepositoryTaskEditorInput(repository, tracTask.getHandleIdentifier(), tracTask.getTaskUrl(), tracTask.getTaskId());
68	} catch (Exception e) {	73	} catch (Exception e) {
69	MylarStatusHandler.fail(e, "Could not create Mantis editor input", true);	74	MylarStatusHandler.fail(e, "Could not create Mantis editor input", true);
70	}	75	}