Attachment #149399 for bug #291084

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

Lines 38-43 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/messages.properties (+1 lines)
38	ScheduleTaskMenuContributor_Not_Scheduled=Not Scheduled	38	ScheduleTaskMenuContributor_Not_Scheduled=Not Scheduled
39	ScheduleTaskMenuContributor_Schedule_for=Schedule for	39	ScheduleTaskMenuContributor_Schedule_for=Schedule for
40		40
		41	TaskActivationExternalizationParticipant_Task_Activation_History=Task Activation History
41	TaskHistoryDropDown_Activate_Task_=Activate Task...	42	TaskHistoryDropDown_Activate_Task_=Activate Task...
42	TaskHistoryDropDown_Deactivate_Task=Deactivate Task	43	TaskHistoryDropDown_Deactivate_Task=Deactivate Task
43		44

Lines 63-68 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/Messages.java (+2 lines)
63		63
64	public static String ScheduleTaskMenuContributor_Schedule_for;	64	public static String ScheduleTaskMenuContributor_Schedule_for;
65		65
		66	public static String TaskActivationExternalizationParticipant_Task_Activation_History;
		67
66	public static String TaskHistoryDropDown_Activate_Task_;	68	public static String TaskHistoryDropDown_Activate_Task_;
67		69
68	public static String TaskHistoryDropDown_Deactivate_Task;	70	public static String TaskHistoryDropDown_Deactivate_Task;

Lines 35-40 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin.java (-3 / +37 lines)
35	import org.eclipse.core.resources.ResourcesPlugin;	35	import org.eclipse.core.resources.ResourcesPlugin;
36	import org.eclipse.core.runtime.Assert;	36	import org.eclipse.core.runtime.Assert;
37	import org.eclipse.core.runtime.CoreException;	37	import org.eclipse.core.runtime.CoreException;
		38	import org.eclipse.core.runtime.IPath;
38	import org.eclipse.core.runtime.IProgressMonitor;	39	import org.eclipse.core.runtime.IProgressMonitor;
39	import org.eclipse.core.runtime.ISafeRunnable;	40	import org.eclipse.core.runtime.ISafeRunnable;
40	import org.eclipse.core.runtime.IStatus;	41	import org.eclipse.core.runtime.IStatus;
Lines 91-96 Link Here
91	import org.eclipse.mylyn.tasks.ui.AbstractTaskRepositoryLinkProvider;	92	import org.eclipse.mylyn.tasks.ui.AbstractTaskRepositoryLinkProvider;
92	import org.eclipse.mylyn.tasks.ui.TasksUi;	93	import org.eclipse.mylyn.tasks.ui.TasksUi;
93	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPageFactory;	94	import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPageFactory;
		95	import org.eclipse.osgi.util.NLS;
94	import org.eclipse.swt.graphics.Image;	96	import org.eclipse.swt.graphics.Image;
95	import org.eclipse.swt.widgets.Display;	97	import org.eclipse.swt.widgets.Display;
96	import org.eclipse.ui.IStartup;	98	import org.eclipse.ui.IStartup;
Lines 355-360 Link Here
355		357
356	private final Set<IRepositoryModelListener> listeners = new HashSet<IRepositoryModelListener>();	358	private final Set<IRepositoryModelListener> listeners = new HashSet<IRepositoryModelListener>();
357		359
		360	private File activationHistoryFile;
		361
358	private static TaskList taskList;	362	private static TaskList taskList;
359		363
360	private static RepositoryModel repositoryModel;	364	private static RepositoryModel repositoryModel;
Lines 413-418 Link Here
413	}	417	}
414	}	418	}
415	}	419	}
		420
416	//taskActivityMonitor.reloadActivityTime();	421	//taskActivityMonitor.reloadActivityTime();
417	} catch (Throwable t) {	422	} catch (Throwable t) {
418	StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,	423	StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
Lines 444-450 Link Here
444	activeContextExternalizationParticipant.registerListeners();	449	activeContextExternalizationParticipant.registerListeners();
445	return new Status(IStatus.OK, TasksUiPlugin.ID_PLUGIN, IStatus.OK, "", null); //$NON-NLS-1$	450	return new Status(IStatus.OK, TasksUiPlugin.ID_PLUGIN, IStatus.OK, "", null); //$NON-NLS-1$
446	}	451	}
447
448	}	452	}
449		453
450	public TasksUiPlugin() {	454	public TasksUiPlugin() {
Lines 514-519 Link Here
514	taskList.addChangeListener(taskListExternalizationParticipant);	518	taskList.addChangeListener(taskListExternalizationParticipant);
515		519
516	taskActivityManager = new TaskActivityManager(repositoryManager, taskList);	520	taskActivityManager = new TaskActivityManager(repositoryManager, taskList);
		521
517	taskActivityManager.addActivationListener(taskListExternalizationParticipant);	522	taskActivityManager.addActivationListener(taskListExternalizationParticipant);
518		523
519	// initialize	524	// initialize
Lines 579-584 Link Here
579	taskActivityManager.addActivityListener(ACTIVITY_EXTERNALIZTAION_PARTICIPANT);	584	taskActivityManager.addActivityListener(ACTIVITY_EXTERNALIZTAION_PARTICIPANT);
580	taskActivityMonitor.setExternalizationParticipant(ACTIVITY_EXTERNALIZTAION_PARTICIPANT);	585	taskActivityMonitor.setExternalizationParticipant(ACTIVITY_EXTERNALIZTAION_PARTICIPANT);
581		586
		587	// initialize externalization for task activation history
		588	IPath stateLocation = Platform.getStateLocation(getBundle());
		589	activationHistoryFile = stateLocation.append("TaskActivationHistory.xml").toFile(); //$NON-NLS-1$
		590	TaskActivationExternalizationParticipant taskActivationExternalizationParticipant = new TaskActivationExternalizationParticipant(
		591	externalizationManager, taskList, taskActivityManager.getTaskActivationHistory(),
		592	activationHistoryFile);
		593	taskActivityManager.addActivationListener(taskActivationExternalizationParticipant);
		594	externalizationManager.addParticipant(taskActivationExternalizationParticipant);
		595
582	// initialize managers	596	// initialize managers
583	initializeDataSources();	597	initializeDataSources();
584		598
Lines 646-653 Link Here
646	repositoryManager.addRepository(taskRepository);	660	repositoryManager.addRepository(taskRepository);
647	}	661	}
648	} catch (Throwable t) {	662	} catch (Throwable t) {
649	StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,	663	StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, NLS.bind(
650	"Could not load repository template", t)); //$NON-NLS-1$	664	"Could not load repository template for repository {0}", template.repositoryUrl), t)); //$NON-NLS-1$
651	}	665	}
652	}	666	}
653	}	667	}
Lines 799-804 Link Here
799	taskActivityMonitor.reloadActivityTime();	813	taskActivityMonitor.reloadActivityTime();
800	taskActivityManager.reloadPlanningData();	814	taskActivityManager.reloadPlanningData();
801		815
		816	if (!activationHistoryFile.exists() && taskActivityManager.getTaskActivationHistory().getSize() == 0) {
		817	// fall back to activity history
		818	List<ITask> tasks = taskActivityMonitor.getActivationHistory();
		819	for (ITask task : tasks) {
		820	taskActivityManager.getTaskActivationHistory().addTask((AbstractTask) task);
		821	}
		822	}
		823
		824	if (!MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
		825	MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED + ".checked")) { //$NON-NLS-1$
		826	if (!taskActivityMonitor.getActivationHistory().isEmpty()) {
		827	// tasks have been active before so fore preference enabled
		828	MonitorUiPlugin.getDefault().getPreferenceStore().setValue(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED,
		829	true);
		830	}
		831	MonitorUiPlugin.getDefault().getPreferenceStore().setValue(
		832	MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED + ".checked", true); //$NON-NLS-1$
		833	MonitorUiPlugin.getDefault().savePluginPreferences();
		834	}
		835
802	// inform listeners that initialization is complete	836	// inform listeners that initialization is complete
803	for (final IRepositoryModelListener listener : listeners) {	837	for (final IRepositoryModelListener listener : listeners) {
804	SafeRunner.run(new ISafeRunnable() {	838	SafeRunner.run(new ISafeRunnable() {

Lines 11-16 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskActivityMonitor.java (-9 / +18 lines)
11		11
12	package org.eclipse.mylyn.internal.tasks.ui;	12	package org.eclipse.mylyn.internal.tasks.ui;
13		13
		14	import java.util.ArrayList;
14	import java.util.List;	15	import java.util.List;
15		16
16	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
Lines 42-47 Link Here
42		43
43	private final TaskList taskList;	44	private final TaskList taskList;
44		45
		46	private final List<ITask> activationHistory;
		47
45	private final AbstractContextListener CONTEXT_LISTENER = new AbstractContextListener() {	48	private final AbstractContextListener CONTEXT_LISTENER = new AbstractContextListener() {
46		49
47	@Override	50	@Override
Lines 64-69 Link Here
64	this.taskActivityManager = taskActivityManager;	67	this.taskActivityManager = taskActivityManager;
65	this.contextManager = contextManager;	68	this.contextManager = contextManager;
66	this.taskList = TasksUiPlugin.getTaskList();	69	this.taskList = TasksUiPlugin.getTaskList();
		70	this.activationHistory = new ArrayList<ITask>();
67	}	71	}
68		72
69	public void start() {	73	public void start() {
Lines 77-83 Link Here
77	if ((event.getDelta().equals(InteractionContextManager.ACTIVITY_DELTA_ACTIVATED))) {	81	if ((event.getDelta().equals(InteractionContextManager.ACTIVITY_DELTA_ACTIVATED))) {
78	AbstractTask activatedTask = taskList.getTask(event.getStructureHandle());	82	AbstractTask activatedTask = taskList.getTask(event.getStructureHandle());
79	if (activatedTask != null) {	83	if (activatedTask != null) {
80	taskActivityManager.getTaskActivationHistory().addTask(activatedTask);	84	activationHistory.add(activatedTask);
81	return true;	85	return true;
82	}	86	}
83	}	87	}
Lines 119-124 Link Here
119	}	123	}
120		124
121	public void reloadActivityTime() {	125	public void reloadActivityTime() {
		126	activationHistory.clear();
122	taskActivityManager.clearActivity();	127	taskActivityManager.clearActivity();
123	List<InteractionEvent> events = contextManager.getActivityMetaContext().getInteractionHistory();	128	List<InteractionEvent> events = contextManager.getActivityMetaContext().getInteractionHistory();
124	for (InteractionEvent event : events) {	129	for (InteractionEvent event : events) {
Lines 129-145 Link Here
129	/**	134	/**
130	* Returns the task corresponding to the interaction event history item at the specified position	135	* Returns the task corresponding to the interaction event history item at the specified position
131	*/	136	*/
132	protected ITask getHistoryTaskAt(int pos) {	137	// protected ITask getHistoryTaskAt(int pos) {
133	InteractionEvent event = contextManager.getActivityMetaContext().getInteractionHistory().get(pos);	138	// InteractionEvent event = contextManager.getActivityMetaContext().getInteractionHistory().get(pos);
134	if (event.getDelta().equals(InteractionContextManager.ACTIVITY_DELTA_ACTIVATED)) {	139	// if (event.getDelta().equals(InteractionContextManager.ACTIVITY_DELTA_ACTIVATED)) {
135	return TasksUiPlugin.getTaskList().getTask(event.getStructureHandle());	140	// return TasksUiPlugin.getTaskList().getTask(event.getStructureHandle());
136	} else {	141	// } else {
137	return null;	142	// return null;
138	}	143	// }
139	}	144	// }
140		145
141	public void setExternalizationParticipant(ActivityExternalizationParticipant participant) {	146	public void setExternalizationParticipant(ActivityExternalizationParticipant participant) {
142	this.externalizationParticipant = participant;	147	this.externalizationParticipant = participant;
143	}	148	}
144		149
		150	public List<ITask> getActivationHistory() {
		151	return new ArrayList<ITask>(activationHistory);
		152	}
		153
145	}	154	}

Lines 17-23 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/ActivityExternalizationParticipant.java (-4 / +18 lines)
17	import org.eclipse.core.runtime.CoreException;	17	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.IProgressMonitor;	18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.jobs.ISchedulingRule;	19	import org.eclipse.core.runtime.jobs.ISchedulingRule;
		20	import org.eclipse.jface.util.IPropertyChangeListener;
20	import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;	21	import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
		22	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
21	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;	23	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
22	import org.eclipse.mylyn.internal.tasks.core.externalization.AbstractExternalizationParticipant;	24	import org.eclipse.mylyn.internal.tasks.core.externalization.AbstractExternalizationParticipant;
23	import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;	25	import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;
Lines 40-45 Link Here
40		42
41	public ActivityExternalizationParticipant(ExternalizationManager manager) {	43	public ActivityExternalizationParticipant(ExternalizationManager manager) {
42	this.manager = manager;	44	this.manager = manager;
		45	MonitorUiPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(new IPropertyChangeListener() {
		46	public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {
		47	if (event.getProperty().equals(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED)) {
		48	requestSave();
		49	}
		50	}
		51	});
43	}	52	}
44		53
45	@Override	54	@Override
Lines 47-53 Link Here
47	Assert.isNotNull(context);	56	Assert.isNotNull(context);
48	switch (context.getKind()) {	57	switch (context.getKind()) {
49	case SAVE:	58	case SAVE:
50	if (ContextCorePlugin.getDefault() != null && ContextCorePlugin.getContextManager() != null) {	59	if (ContextCorePlugin.getDefault() != null && MonitorUiPlugin.getDefault().isActivityTrackingEnabled()
		60	&& ContextCorePlugin.getContextManager() != null) {
51	setDirty(false);	61	setDirty(false);
52	ContextCorePlugin.getContextManager().saveActivityMetaContext();	62	ContextCorePlugin.getContextManager().saveActivityMetaContext();
53	}	63	}
Lines 105-114 Link Here
105		115
106	public void elapsedTimeUpdated(ITask task, long newElapsedTime) {	116	public void elapsedTimeUpdated(ITask task, long newElapsedTime) {
107	if (System.currentTimeMillis() - lastUpdate > 1000 * 60) {	117	if (System.currentTimeMillis() - lastUpdate > 1000 * 60) {
108	setDirty(true);	118	requestSave();
109	manager.requestSave();
110	lastUpdate = System.currentTimeMillis();
111	}	119	}
112	}	120	}
113		121
		122	private void requestSave() {
		123	setDirty(true);
		124	manager.requestSave();
		125	lastUpdate = System.currentTimeMillis();
		126	}
		127
114	}	128	}

Lines 88-91 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorPlanningPart.java (+4 lines)
88	part.dispose();	88	part.dispose();
89	}	89	}
90		90
		91	public PlanningPart getPlanningPart() {
		92	return part;
		93	}
		94
91	}	95	}





import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.mylyn.commons.core.DateUtil;
import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonTextSupport;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;
import org.eclipse.mylyn.internal.provisional.commons.ui.DatePicker;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.DateRange;
import org.eclipse.mylyn.internal.tasks.core.DayDateRange;
import org.eclipse.mylyn.internal.tasks.core.ITaskListChangeListener;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;

import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.util.PlatformUtil;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.monitor.ui.MonitorUi;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskActivityListener;
import org.eclipse.mylyn.tasks.core.TaskActivityAdapter;

import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ImageHyperlink;
import org.eclipse.ui.forms.widgets.Section;

/**


	private DatePicker dueDatePicker;

	private Text activeTimeText;

	private Spinner estimatedTimeSpinner;

	private ScheduleDatePicker scheduleDatePicker;

	private Label scheduledText;

	private static final String PERSONAL_NOTES = Messages.PlanningPart_Personal_Notes;

	private final ITaskListChangeListener TASK_LIST_LISTENER = new TaskListChangeAdapter() {

			if (task.equals(PlanningPart.this.getTask())) {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						if (activeTimeText != null && !activeTimeText.isDisposed()) {
							updateActiveTime();
						}
					}
				});
			}
		}
	};

	private final IPropertyChangeListener ACTIVITY_PROPERTY_LISTENER = new org.eclipse.jface.util.IPropertyChangeListener() {

		public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {
			if (event.getProperty().equals(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED)) {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						if (activeTimeText != null && !activeTimeText.isDisposed()) {
							updateActiveTime();
						}
					}
				});
			}
		}

	};

	private CommonTextSupport textSupport;

	private TaskFormPage page;

	private Composite activeTimeComposite;

	private ToolBarManager toolBarManager;



	private Composite sectionClient;

	private boolean activeTimeEnabled;

	public PlanningPart(int sectionStyle) {
		super(sectionStyle, Messages.PersonalPart_Personal_Planning);
		this.activeTimeEnabled = true;
		this.needsNotes = true;
	}


			getTask().setReminded(false);
		}

		if (estimatedTimeSpinner != null) {
			getTask().setEstimatedTimeHours(estimatedTimeSpinner.getSelection());
		}

		if (dueDatePicker != null && dueDatePicker.getDate() != null) {


		TasksUiInternal.getTaskList().addChangeListener(TASK_LIST_LISTENER);
		TasksUiPlugin.getTaskActivityManager().addActivityListener(timingListener);
		MonitorUiPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(ACTIVITY_PROPERTY_LISTENER);

		setSection(toolkit, section);
		return section;

	private void expandSection(FormToolkit toolkit, Section section) {
		sectionClient = toolkit.createComposite(section);
		GridLayout layout = EditorUtil.createSectionClientLayout();
		layout.numColumns = (needsDueDate) ? 6 : 4;
		sectionClient.setLayout(layout);

		createScheduledDatePicker(toolkit, sectionClient);


		createEstimatedTime(toolkit, sectionClient);

//		createActualTime(toolkit, composite);

		if (needsNotes()) {
			createNotesArea(toolkit, sectionClient, layout.numColumns);


	}

	private void createActiveTimeControl(FormToolkit toolkit, Composite toolbarComposite) {
		activeTimeComposite = toolkit.createComposite(toolbarComposite);
		activeTimeComposite.setBackground(null);
		activeTimeComposite.setBackgroundMode(SWT.INHERIT_FORCE);
		RowLayout rowLayout = new RowLayout();
		rowLayout.center = true;
		rowLayout.marginTop = 0;
		rowLayout.marginBottom = 0;
		rowLayout.marginLeft = 0;
		rowLayout.marginRight = 0;
		activeTimeComposite.setLayout(rowLayout);

		Label label = toolkit.createLabel(activeTimeComposite, Messages.TaskEditorPlanningPart_Active);
		label.setForeground(toolkit.getColors().getColor(IFormColors.TITLE));
		label.setToolTipText(Messages.TaskEditorPlanningPart_Time_working_on_this_task);
		label.setBackground(null);

		activeTimeText = new Text(activeTimeComposite, SWT.FLAT | SWT.READ_ONLY);
		activeTimeText.setFont(EditorUtil.TEXT_FONT);
		activeTimeText.setData(FormToolkit.KEY_DRAW_BORDER, Boolean.FALSE);
		toolkit.adapt(activeTimeText, true, false);
		activeTimeText.setForeground(toolkit.getColors().getColor(IFormColors.TITLE));
		activeTimeText.setBackground(null);
		updateActiveTime();
		activeTimeText.setEditable(false);

//		ImageHyperlink resetActivityTimeButton = toolkit.createImageHyperlink(activeTimeComposite, SWT.NONE);
//		resetActivityTimeButton.setBackground(null);
//		resetActivityTimeButton.setImage(CommonImages.getImage(CommonImages.FIND_CLEAR_DISABLED));
//		resetActivityTimeButton.setHoverImage(CommonImages.getImage(CommonImages.FIND_CLEAR));
//		resetActivityTimeButton.setToolTipText(Messages.TaskEditorPlanningPart_Reset);
//		resetActivityTimeButton.addHyperlinkListener(new HyperlinkAdapter() {
//			@Override
//			public void linkActivated(HyperlinkEvent e) {
//				if (MessageDialog.openConfirm(getControl().getShell(),
//						Messages.TaskEditorPlanningPart_Confirm_Activity_Time_Deletion,
//						Messages.TaskEditorPlanningPart_Do_you_wish_to_reset_your_activity_time_on_this_task_)) {
//					MonitorUi.getActivityContextManager().removeActivityTime(getTask().getHandleIdentifier(), 0l,
//							System.currentTimeMillis());
//				}
//			}
//		});
	}

	private void updateActiveTime() {
		long elapsedTime = 0;
		if (isActiveTimeEnabled() && MonitorUiPlugin.getDefault().isActivityTrackingEnabled()) {
			elapsedTime = TasksUiPlugin.getTaskActivityManager().getElapsedTime(getTask());
		}

	private void updateElapsedTime() {
		long elapsedTime = TasksUiPlugin.getTaskActivityManager().getElapsedTime(getTask());
		if (elapsedTime > 0) {
			if (activeTimeComposite != null && !activeTimeComposite.isVisible()) {
				activeTimeComposite.setVisible(true);
			}
		} else {
			if (activeTimeComposite != null) {
				activeTimeComposite.setVisible(false);
			}
		}
		String elapsedTimeString = DateUtil.getFormattedDurationShort(elapsedTime);
		if (elapsedTimeString.equals("")) { //$NON-NLS-1$
			elapsedTimeString = Messages.TaskEditorPlanningPart_0_SECOUNDS;
		}
		activeTimeText.setText(elapsedTimeString);

	}



	private void createEstimatedTime(FormToolkit toolkit, Composite parent) {
		Label label = toolkit.createLabel(parent, Messages.TaskEditorPlanningPart_Estimated);
		label.setToolTipText(Messages.PlanningPart_Estimated_Time_Hours);
		label.setForeground(toolkit.getColors().getColor(IFormColors.TITLE));

		Composite composite = createComposite(parent, 2, toolkit);

		// Estimated time
		estimatedTimeSpinner = new Spinner(composite, SWT.FLAT);
		estimatedTimeSpinner.setDigits(0);
		estimatedTimeSpinner.setMaximum(10000);
		estimatedTimeSpinner.setMinimum(0);
		estimatedTimeSpinner.setIncrement(1);
		estimatedTimeSpinner.setSelection(getTask().getEstimatedTimeHours());
		if (!PlatformUtil.spinnerHasNativeBorder()) {
			estimatedTimeSpinner.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TREE_BORDER);
		}
		estimatedTimeSpinner.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				if (getTask().getEstimatedTimeHours() != estimatedTimeSpinner.getSelection()) {
					markDirty();
				}
			}
		});

//		ImageHyperlink clearEstimated = toolkit.createImageHyperlink(composite, SWT.NONE);
//		clearEstimated.setImage(CommonImages.getImage(CommonImages.FIND_CLEAR_DISABLED));
//		clearEstimated.setHoverImage(CommonImages.getImage(CommonImages.FIND_CLEAR));
//		clearEstimated.setToolTipText(Messages.TaskEditorPlanningPart_Clear);
//		clearEstimated.addHyperlinkListener(new HyperlinkAdapter() {
//			@Override
//			public void linkActivated(HyperlinkEvent e) {
//				estimatedTime.setSelection(0);
//				markDirty();
//			}
//		});
		toolkit.paintBordersFor(composite);
	}


	public void dispose() {
		TasksUiPlugin.getTaskActivityManager().removeActivityListener(timingListener);
		TasksUiInternal.getTaskList().removeChangeListener(TASK_LIST_LISTENER);
		MonitorUiPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(ACTIVITY_PROPERTY_LISTENER);

		if (toolBarManager != null) {
			toolBarManager.dispose();

	@Override
	protected void setSection(FormToolkit toolkit, Section section) {
		if (section.getTextClient() == null) {
			Composite toolbarComposite = toolkit.createComposite(section);
			toolbarComposite.setBackground(null);
			RowLayout rowLayout = new RowLayout();
			rowLayout.marginLeft = 0;

			rowLayout.center = true;
			toolbarComposite.setLayout(rowLayout);

			createActiveTimeControl(toolkit, toolbarComposite);
			createScheduledText(toolkit, toolbarComposite);

			ToolBarManager toolBarManager = new ToolBarManager(SWT.FLAT);
			fillToolBar(toolBarManager);

		super.setSection(toolkit, section);
	}

	private void createScheduledText(FormToolkit toolkit, Composite toolbarComposite) {
		DateRange scheduledForDate = getTask().getScheduledForDate();
		String scheduledString = Messages.TaskEditorPlanningPart_No_scheduled_date;
		if (scheduledForDate != null) {
			scheduledString = scheduledForDate.toString();
		}
		scheduledText = toolkit.createLabel(toolbarComposite, scheduledString, SWT.READ_ONLY);
		scheduledText.setForeground(toolkit.getColors().getColor(IFormColors.TITLE));
		scheduledText.setBackground(null);
	}

	protected void fillToolBar(ToolBarManager toolBarManager) {
	}



	@Override
	protected void refresh(boolean discardChanges) {
		if (scheduleDatePicker != null && !scheduleDatePicker.isDisposed()) {
			if (getTask().getScheduledForDate() != null) {
				scheduleDatePicker.setScheduledDate(getTask().getScheduledForDate());
			} else {
			if (scheduledText != null && !scheduledText.isDisposed()) {
				scheduledText.setText(getTask().getScheduledForDate().toString());
				toolbarComposite.getParent().layout(true);

			}
		} else {
			if (scheduleDatePicker != null && !scheduleDatePicker.isDisposed()) {
				scheduleDatePicker.setScheduledDate(null);
			}
			if (scheduledText != null && !scheduledText.isDisposed()) {
				scheduledText.setText(Messages.TaskEditorPlanningPart_No_scheduled_date);
				toolbarComposite.getParent().layout(true);
			}
		}

		if (estimatedTimeSpinner != null && !estimatedTimeSpinner.isDisposed()) {
			estimatedTimeSpinner.setSelection(getTask().getEstimatedTimeHours());
		}

		// TODO refresh notes
	}

	public boolean isActiveTimeEnabled() {
		return activeTimeEnabled;
	}

	public void setActiveTimeEnabled(boolean activeTimeEnabled) {
		this.activeTimeEnabled = activeTimeEnabled;
		if (activeTimeComposite != null && !activeTimeComposite.isDisposed()) {
			updateActiveTime();
		}
	}

}

Lines 41-46 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/preferences/Messages.java (+4 lines)
41		41
42	public static String TasksUiPreferencePage_Enable_inactivity_timeouts;	42	public static String TasksUiPreferencePage_Enable_inactivity_timeouts;
43		43
		44	public static String TasksUiPreferencePage_Enable_Time_Tracking;
		45
44	public static String TasksUiPreferencePage_Error_applying_Task_List_data_directory_changes;	46	public static String TasksUiPreferencePage_Error_applying_Task_List_data_directory_changes;
45		47
46	public static String TasksUiPreferencePage_Folder_Selection;	48	public static String TasksUiPreferencePage_Folder_Selection;
Lines 79-84 Link Here
79		81
80	public static String TasksUiPreferencePage_Task_Timing;	82	public static String TasksUiPreferencePage_Task_Timing;
81		83
		84	public static String TasksUiPreferencePage_Track_Time_Spent;
		85
82	public static String TasksUiPreferencePage_Use_the_Restore_dialog_to_recover_missing_tasks;	86	public static String TasksUiPreferencePage_Use_the_Restore_dialog_to_recover_missing_tasks;
83		87
84	public static String TasksUiPreferencePage_Web_Browser;	88	public static String TasksUiPreferencePage_Web_Browser;





	private Combo weekStartCombo;

	private Button activityTrackingEnabledButton;

	private Label timeoutLabel1;

	private Label timeoutLabel2;

	public TasksUiPreferencePage() {
		super();
		setPreferenceStore(TasksUiPlugin.getDefault().getPreferenceStore());

		GridLayout layout = new GridLayout(1, false);
		container.setLayout(layout);

		if (getContainer() instanceof IWorkbenchPreferenceContainer) {
			String message = Messages.TasksUiPreferencePage_See_X_for_configuring_Task_List_colors;
			new PreferenceLinkArea(container, SWT.NONE, "org.eclipse.ui.preferencePages.ColorsAndFonts", message, //$NON-NLS-1$
					(IWorkbenchPreferenceContainer) getContainer(), null);
		}

		createTaskRefreshScheduleGroup(container);
		createSchedulingGroup(container);
		createOpenWith(container);
		createTaskActivityGroup(container);
		Composite advanced = createAdvancedSection(container);
		createTaskActivityGroup(advanced);
		createTaskDataControl(advanced);
		createLinks(container);

		if (getContainer() instanceof IWorkbenchPreferenceContainer) {
			String message = Messages.TasksUiPreferencePage_See_X_for_configuring_Task_List_colors;
			new PreferenceLinkArea(advanced, SWT.NONE, "org.eclipse.ui.preferencePages.ColorsAndFonts", message, //$NON-NLS-1$
					(IWorkbenchPreferenceContainer) getContainer(), null);
		}

		createLinks(advanced);
		updateRefreshGroupEnablements();
		applyDialogFont(container);
		return container;

				timeoutEnabledButton.getSelection());
		MonitorUiPlugin.getDefault().getPreferenceStore().setValue(ActivityContextManager.ACTIVITY_TIMEOUT,
				timeoutMinutes.getSelection() * (60 * 1000));

		MonitorUiPlugin.getDefault().getPreferenceStore().setValue(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED,
				activityTrackingEnabledButton.getSelection());

		String taskDirectory = taskDirectoryText.getText();
		taskDirectory = taskDirectory.replaceAll(BACKSLASH_MULTI, FORWARDSLASH);

		timeoutMinutes.setSelection(minutes);
		timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
				ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));

		activityTrackingEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
				MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED));

		return true;
	}


		timeoutMinutes.setSelection(activityTimeoutMinutes);
		timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getDefaultBoolean(
				ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));

		activityTrackingEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getDefaultBoolean(
				MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED));

		updateRefreshGroupEnablements();
	}



				if (taskDataDirectoryAction != IDialogConstants.CANCEL_ID) {
					taskDirectoryText.setText(dir);
//					backupFolderText.setText(dir + FORWARDSLASH + ITasksCoreConstants.DEFAULT_BACKUP_FOLDER_NAME);
//					backupNow.setEnabled(false);
				}
			}

		});

//		Composite backupComposite = new Composite(taskDataGroup, SWT.NULL);
//		gridLayout = new GridLayout(5, false);
//		gridLayout.marginWidth = 0;
//		gridLayout.marginHeight = 0;
//		backupComposite.setLayout(gridLayout);
//		backupComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

//		label = new Label(backupComposite, SWT.NULL);
//		label.setText("Backup every");
//		backupScheduleTimeText = new Text(backupComposite, SWT.BORDER | SWT.RIGHT);
//		final GridData gridData_1 = new GridData();
//		gridData_1.widthHint = 13;
//		backupScheduleTimeText.setLayoutData(gridData_1);
//
//		backupScheduleTimeText.setText("" + getPreferenceStore().getInt(TasksUiPreferenceConstants.BACKUP_SCHEDULE));
//		backupScheduleTimeText.addModifyListener(new ModifyListener() {
//			public void modifyText(ModifyEvent e) {
//				updateRefreshGroupEnablements();
//			}
//		});
//
//		label = new Label(backupComposite, SWT.NONE);
//		label.setText("days to");

//		String backupDirectory = TasksUiPlugin.getDefault().getBackupFolderPath();// getPreferenceStore().getString(TaskListPreferenceConstants.BACKUP_FOLDER);
//		backupDirectory = backupDirectory.replaceAll(BACKSLASH_MULTI, FORWARDSLASH);
//		backupFolderText = new Text(backupComposite, SWT.BORDER);
//		backupFolderText.setText(backupDirectory);
//		backupFolderText.setEditable(false);
//		backupFolderText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
//
//		backupNow = new Button(backupComposite, SWT.NONE);
//		backupNow.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END));
//		backupNow.setText("Backup Now");
//		backupNow.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				TasksUiPlugin.getBackupManager().backupNow(true);
//			}
//		});
	}

	private void createSchedulingGroup(Composite container) {

		weekStartCombo.add(CommonMessages.Saturday);
		weekStartCombo.select(getPreferenceStore().getInt(ITasksUiPreferenceConstants.WEEK_START_DAY) - 1);

//		 Label workWeekBeginLabel = new Label(group, SWT.NONE);
//		 workWeekBeginLabel.setText(START_DAY_LABEL);
//		 workWeekBegin = new Combo(group, SWT.READ_ONLY);
//		 // Calendar.SUNDAY = 1
//		 workWeekBegin.add("SUNDAY");
//		 workWeekBegin.add("MONDAY");
//		 workWeekBegin.add("TUESDAY");
//		 workWeekBegin.add("WEDNESDAY");
//		 workWeekBegin.add("THURSDAY");
//		 workWeekBegin.add("FRIDAY");
//		 workWeekBegin.add("SATURDAY");
//		 workWeekBegin.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_STARTDAY)
//		 - 1);

//		 Label workWeekEndLabel = new Label(group, SWT.NONE);
//		 workWeekEndLabel.setText(END_DAY_LABEL);
//		 workWeekEnd = new Combo(group, SWT.READ_ONLY);
//		 workWeekEnd.add("SUNDAY");
//		 workWeekEnd.add("MONDAY");
//		 workWeekEnd.add("TUESDAY");
//		 workWeekEnd.add("WEDNESDAY");
//		 workWeekEnd.add("THURSDAY");
//		 workWeekEnd.add("FRIDAY");
//		 workWeekEnd.add("SATURDAY");
//		 workWeekEnd.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_ENDDAY)
//		 - 1);

//		Label hourDayStartLabel = new Label(group, SWT.NONE);
//		hourDayStartLabel.setText(START_HOUR_LABEL);
//		hourDayStart = new Spinner(group, SWT.BORDER);
//		hourDayStart.setDigits(0);
//		hourDayStart.setIncrement(1);
//		hourDayStart.setMaximum(23);
//		hourDayStart.setMinimum(0);
//		hourDayStart.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_STARTHOUR));
//		hourDayStart.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				updateRefreshGroupEnablements();
//			}
//
//		});
//
//		Label spacer = new Label(group, SWT.NONE);
//		GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
//
//		Label hourDayEndLabel = new Label(group, SWT.NONE);
//		hourDayEndLabel.setText(END_HOUR_LABEL);
//
//		hourDayEnd = new Spinner(group, SWT.BORDER);
//		hourDayEnd.setDigits(0);
//		hourDayEnd.setIncrement(1);
//		hourDayEnd.setMaximum(23);
//		hourDayEnd.setMinimum(0);
//		hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
//		hourDayEnd.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				updateRefreshGroupEnablements();
//			}
//
//		});

	}

	private void createTaskActivityGroup(Composite container) {

		group.setLayout(new GridLayout(3, false));
		group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		boolean activityTrackingEnabled = MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
				MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED);

		boolean timeoutEnabled = MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
				ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED);

		activityTrackingEnabledButton = new Button(group, SWT.CHECK);
		activityTrackingEnabledButton.setText(Messages.TasksUiPreferencePage_Enable_Time_Tracking);
		activityTrackingEnabledButton.setSelection(activityTrackingEnabled);
		activityTrackingEnabledButton.setToolTipText(Messages.TasksUiPreferencePage_Track_Time_Spent);
		activityTrackingEnabledButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				updateRefreshGroupEnablements();
			}
		});
		GridDataFactory.swtDefaults().span(3, 1).applyTo(activityTrackingEnabledButton);

		timeoutEnabledButton = new Button(group, SWT.CHECK);
		timeoutEnabledButton.setText(Messages.TasksUiPreferencePage_Enable_inactivity_timeouts);
		timeoutEnabledButton.setSelection(timeoutEnabled);

		});
		GridDataFactory.swtDefaults().span(3, 1).applyTo(timeoutEnabledButton);

		timeoutLabel1 = new Label(group, SWT.NONE);
		timeoutLabel1.setText(Messages.TasksUiPreferencePage_Stop_time_accumulation_after);
		timeoutMinutes = new Spinner(group, SWT.BORDER);
		timeoutMinutes.setDigits(0);
		timeoutMinutes.setIncrement(5);


		});

		timeoutLabel2 = new Label(group, SWT.NONE);
		timeoutLabel2.setText(Messages.TasksUiPreferencePage_minutes_of_inactivity);

	}
//		GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
//
//		Label hourDayEndLabel = new Label(group, SWT.NONE);
//		hourDayEndLabel.setText(END_HOUR_LABEL);
//
//		hourDayEnd = new Spinner(group, SWT.BORDER);
//		hourDayEnd.setDigits(0);
//		hourDayEnd.setIncrement(1);
//		hourDayEnd.setMaximum(23);
//		hourDayEnd.setMinimum(0);
//		hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
//		hourDayEnd.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				updateRefreshGroupEnablements();
//			}
//
//		});

	}

//	private void createSchedulingGroup(Composite container) {
//		Group group = new Group(container, SWT.SHADOW_ETCHED_IN);
//		group.setText(GROUP_WORK_WEEK_LABEL);
//		group.setLayout(new GridLayout(5, false));
//		group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
//
//		// Label workWeekBeginLabel = new Label(group, SWT.NONE);
//		// workWeekBeginLabel.setText(START_DAY_LABEL);
//		// workWeekBegin = new Combo(group, SWT.READ_ONLY);
//		// // Calendar.SUNDAY = 1
//		// workWeekBegin.add("SUNDAY");
//		// workWeekBegin.add("MONDAY");
//		// workWeekBegin.add("TUESDAY");
//		// workWeekBegin.add("WEDNESDAY");
//		// workWeekBegin.add("THURSDAY");
//		// workWeekBegin.add("FRIDAY");
//		// workWeekBegin.add("SATURDAY");
//		// workWeekBegin.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_STARTDAY)
//		// - 1);
//		//		
//		// Label workWeekEndLabel = new Label(group, SWT.NONE);
//		// workWeekEndLabel.setText(END_DAY_LABEL);
//		// workWeekEnd = new Combo(group, SWT.READ_ONLY);
//		// workWeekEnd.add("SUNDAY");
//		// workWeekEnd.add("MONDAY");
//		// workWeekEnd.add("TUESDAY");
//		// workWeekEnd.add("WEDNESDAY");
//		// workWeekEnd.add("THURSDAY");
//		// workWeekEnd.add("FRIDAY");
//		// workWeekEnd.add("SATURDAY");
//		// workWeekEnd.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_ENDDAY)
//		// - 1);
//
//		Label hourDayStartLabel = new Label(group, SWT.NONE);
//		hourDayStartLabel.setText(START_HOUR_LABEL);
//		hourDayStart = new Spinner(group, SWT.BORDER);
//		hourDayStart.setDigits(0);
//		hourDayStart.setIncrement(1);
//		hourDayStart.setMaximum(23);
//		hourDayStart.setMinimum(0);
//		hourDayStart.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_STARTHOUR));
//		hourDayStart.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				updateRefreshGroupEnablements();
//			}
//
//		});
//
//		Label spacer = new Label(group, SWT.NONE);
//		GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
//
//		Label hourDayEndLabel = new Label(group, SWT.NONE);
//		hourDayEndLabel.setText(END_HOUR_LABEL);
//
//		hourDayEnd = new Spinner(group, SWT.BORDER);
//		hourDayEnd.setDigits(0);
//		hourDayEnd.setIncrement(1);
//		hourDayEnd.setMaximum(23);
//		hourDayEnd.setMinimum(0);
//		hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
//		hourDayEnd.addSelectionListener(new SelectionAdapter() {
//
//			@Override
//			public void widgetSelected(SelectionEvent e) {
//				updateRefreshGroupEnablements();
//			}
//
//		});
//
//	}

	public void updateRefreshGroupEnablements() {
		String errorMessage = null;

//		try {
//			long number = Integer.parseInt(backupScheduleTimeText.getText());
//			if (number <= 0) {
//				errorMessage = "Backup schedule time must be > 0";
//			} else if (backupFolderText.getText() == "") {
//				errorMessage = "Backup destination folder must be specified";
//			}
//		} catch (NumberFormatException e) {
//			errorMessage = "Backup schedule time must be valid integer";
//		}

		if (enableBackgroundSynch.getSelection()) {
			try {
				long number = Long.parseLong(synchScheduleTime.getText());

			}
		}

//		if (hourDayEnd.getSelection() <= hourDayStart.getSelection()) {
//			errorMessage = "Planning: Work day start must be before end.";
//		}

		setErrorMessage(errorMessage);
		setValid(errorMessage == null);

		if (activityTrackingEnabledButton.getSelection()) {
			timeoutEnabledButton.setEnabled(true);
			synchScheduleTime.setEnabled(enableBackgroundSynch.getSelection());
			timeoutMinutes.setEnabled(timeoutEnabledButton.getSelection());
			timeoutLabel1.setEnabled(timeoutEnabledButton.getSelection());
			timeoutLabel2.setEnabled(timeoutEnabledButton.getSelection());
		} else {
			timeoutEnabledButton.setEnabled(false);
			synchScheduleTime.setEnabled(false);
			timeoutMinutes.setEnabled(false);
			timeoutLabel1.setEnabled(false);
			timeoutLabel2.setEnabled(false);
		}
	}

	private String getMinutesString() {

Lines 35-40 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/messages.properties (+1 lines)
35	TaskListSorter_Catagory_and_Repository=Category and Repository	35	TaskListSorter_Catagory_and_Repository=Category and Repository
36	TaskListSorter_No_Grouping=None	36	TaskListSorter_No_Grouping=None
37		37
		38	TaskListToolTip_Active_X=Active: {0}
38	TaskListToolTip_Automatic_container_for_all_local_tasks=Automatic container for all local tasks\nwith no category set	39	TaskListToolTip_Automatic_container_for_all_local_tasks=Automatic container for all local tasks\nwith no category set
39	TaskListToolTip_Automatic_container_for_repository_tasks=Automatic container for repository tasks\nnot matched by any query	40	TaskListToolTip_Automatic_container_for_repository_tasks=Automatic container for repository tasks\nnot matched by any query
40	TaskListToolTip_Due=Due: {0}, {1} ({2})	41	TaskListToolTip_Due=Due: {0}, {1} ({2})

Lines 69-74 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/Messages.java (+2 lines)
69		69
70	public static String TaskListSorter_No_Grouping;	70	public static String TaskListSorter_No_Grouping;
71		71
		72	public static String TaskListToolTip_Active_X;
		73
72	public static String TaskListToolTip_Automatic_container_for_all_local_tasks;	74	public static String TaskListToolTip_Automatic_container_for_all_local_tasks;
73		75
74	public static String TaskListToolTip_Automatic_container_for_repository_tasks;	76	public static String TaskListToolTip_Automatic_container_for_repository_tasks;




import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.mylyn.commons.core.DateUtil;
import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonFonts;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;

		if (element instanceof ScheduledTaskContainer) {
			ScheduledTaskContainer container = (ScheduledTaskContainer) element;
			int estimateTotal = 0;
			long activeTotal = 0;
			for (ITask child : container.getChildren()) {
				if (child instanceof AbstractTask) {
					estimateTotal += ((AbstractTask) child).getEstimatedTimeHours();
					activeTotal += TasksUiPlugin.getTaskActivityManager().getElapsedTime(child,
							container.getDateRange());
				}
			}
			StringBuilder sb = new StringBuilder();
			appendEstimateAndActive(sb, estimateTotal, activeTotal);
			sb.append("\n"); //$NON-NLS-1$
			sb.append(NLS.bind(Messages.TaskListToolTip_Elapsed, DateUtil.getFormattedDurationShort(elapsedTotal)));
			sb.append("\n"); //$NON-NLS-1$
			return sb.toString();
		} else if (element instanceof ITask) {
			ITask task = (ITask) element;

		}
	}

	private void appendEstimateAndActive(StringBuilder sb, int estimateTotal, long activeTotal) {
		if (!MonitorUiPlugin.getDefault().isActivityTrackingEnabled()) {
			return;
		}

		sb.append(NLS.bind(Messages.TaskListToolTip_Estimate, estimateTotal));
		sb.append("\n"); //$NON-NLS-1$
		sb.append(NLS.bind(Messages.TaskListToolTip_Active_X, DateUtil.getFormattedDurationShort(activeTotal)));
		sb.append("\n"); //$NON-NLS-1$
	}

	private String getRepositoryLabel(String repositoryKind, String repositoryUrl) {
		TaskRepository repository = TasksUi.getRepositoryManager().getRepository(repositoryKind, repositoryUrl);
		if (repository != null) {

	}

	private String getActivityText(IRepositoryElement element) {
//		if (element instanceof ScheduledTaskDelegate) {
//			ScheduledTaskDelegate task = (ScheduledTaskDelegate) element;
//
//			StringBuilder sb = new StringBuilder();
//			Date date = task.getScheduledForDate();
//			if (date != null) {
//				sb.append("Scheduled for: ");
//				sb.append(new SimpleDateFormat("E").format(date)).append(", ");
//				sb.append(DateFormat.getDateInstance(DateFormat.LONG).format(date));
//				sb.append(" (").append(DateFormat.getTimeInstance(DateFormat.SHORT).format(date)).append(")\n");
//			}
//
//			long elapsed = TasksUiPlugin.getTaskActivityManager().getElapsedTime(task.getCorrespondingTask(),
//					task.getDateRangeContainer().getStart(), task.getDateRangeContainer().getEnd());
//			String elapsedTimeString = DateUtil.getFormattedDurationShort(elapsed);
//			sb.append("Elapsed: ");
//			sb.append(elapsedTimeString);
//			sb.append("\n");
//
//			return sb.toString();
//		} else 
//			
		if (element instanceof ITask) {
			AbstractTask task = (AbstractTask) element;


				sb.append(NLS.bind(Messages.TaskListToolTip_Scheduled, scheduledDate.toString()));
				sb.append("\n"); //$NON-NLS-1$
			}

			long elapsed = TasksUiPlugin.getTaskActivityManager().getElapsedTime(task);
			appendEstimateAndActive(sb, (task).getEstimatedTimeHours(), elapsed);
			sb.append("\n"); //$NON-NLS-1$

			return sb.toString();
		}
		return null;




/*******************************************************************************
 * Copyright (c) 2009 Tasktop Technologies and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.core.TaskActivationHistory;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.externalization.AbstractExternalizationParticipant;
import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.XMLMemento;

/**
 * @author Steffen Pingel
 */
public class TaskActivationExternalizationParticipant extends AbstractExternalizationParticipant implements
		ITaskActivationListener {

	private final ExternalizationManager externalizationManager;

	private boolean dirty;

	private final TaskActivationHistory activationHistory;

	private final File file;

	private final TaskList taskList;

	public TaskActivationExternalizationParticipant(ExternalizationManager externalizationManager, TaskList taskList,
			TaskActivationHistory history, File file) {
		this.externalizationManager = externalizationManager;
		this.taskList = taskList;
		this.activationHistory = history;
		this.file = file;
	}

	@Override
	public String getDescription() {
		return Messages.TaskActivationExternalizationParticipant_Task_Activation_History;
	}

	@Override
	public ISchedulingRule getSchedulingRule() {
		return ITasksCoreConstants.ACTIVITY_SCHEDULING_RULE;
	}

	@Override
	public boolean isDirty() {
		return dirty;
	}

	private void requestSave() {
		synchronized (TaskActivationExternalizationParticipant.this) {
			dirty = true;
		}
		externalizationManager.requestSave();
	}

	@Override
	public void load(File sourceFile, IProgressMonitor monitor) throws CoreException {
		try {
			activationHistory.clear();
			if (file.exists()) {
				FileReader reader = new FileReader(file);
				try {
					XMLMemento memento = XMLMemento.createReadRoot(reader);
					IMemento[] items = memento.getChildren("task"); //$NON-NLS-1$
					for (IMemento child : items) {
						String handle = child.getString("handle"); //$NON-NLS-1$
						if (handle != null) {
							AbstractTask task = taskList.getTask(handle);
							if (task != null) {
								activationHistory.addTaskInternal(task);
							}
						}
					}
				} finally {
					reader.close();
				}
			}
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
					"Failed to load task activation history", e)); //$NON-NLS-1$
		}
	}

	@Override
	public void save(File targetFile, IProgressMonitor monitor) throws CoreException {
		synchronized (TaskActivationExternalizationParticipant.this) {
			dirty = false;
		}

		XMLMemento memento = XMLMemento.createWriteRoot("taskActivationHistory"); //$NON-NLS-1$
		for (AbstractTask task : activationHistory.getPreviousTasks()) {
			IMemento child = memento.createChild("task"); //$NON-NLS-1$
			child.putString("handle", task.getHandleIdentifier()); //$NON-NLS-1$
		}

		try {
			file.getParentFile().mkdirs();
			FileWriter writer = new FileWriter(file);
			try {
				memento.save(writer);
			} finally {
				writer.close();
			}
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
					"Failed to save task activation history", e)); //$NON-NLS-1$
		}
	}

	@Override
	public String getFileName() {
		return file.getName();
	}

	@Override
	public File getFile(String rootPath) throws CoreException {
		return file;
	}

	public void preTaskActivated(ITask task) {
		// ignore
	}

	public void preTaskDeactivated(ITask task) {
		// ignore
	}

	public void taskActivated(ITask task) {
		activationHistory.addTask((AbstractTask) task);
		requestSave();
	}

	public void taskDeactivated(ITask task) {
		// ignore		
	}

}

Lines 144-150 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java (-1 / +2 lines)
144		144
145	public void clearActivity() {	145	public void clearActivity() {
146	activeTasks.clear();	146	activeTasks.clear();
147	taskActivationHistory.clear();	147	// handled in TaskActivationExternalizationParticipant now
		148	//taskActivationHistory.clear();
148	taskElapsedTimeMap.clear();	149	taskElapsedTimeMap.clear();
149	workingSetElapsedTimeMap.clear();	150	workingSetElapsedTimeMap.clear();
150	}	151	}




import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
import org.eclipse.mylyn.context.core.ContextChangeEvent;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionContext;
import org.eclipse.mylyn.context.core.IInteractionElement;
import org.eclipse.mylyn.context.core.IInteractionRelation;
import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
import org.eclipse.mylyn.context.ui.IContextUiStartup;
import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;
import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;
import org.eclipse.mylyn.monitor.ui.MonitorUi;
import org.eclipse.mylyn.tasks.core.ITask;


	private static final ITaskActivationListener TASK_ACTIVATION_LISTENER = new TaskActivationAdapter() {

		@SuppressWarnings("restriction")
		@Override
		public void taskActivated(ITask task) {
			if (CoreUtil.TEST_MODE) {

		}
	}

	@SuppressWarnings("restriction")
	private void lazyStart(IWorkbench workbench) {
		try {
			MonitorUiPlugin.getDefault()
					.getPreferenceStore()
					.setValue(MonitorUiPlugin.PREF_USER_ACTIVITY_ENABLED, true);
			MonitorUiPlugin.getDefault().savePluginPreferences();
			ContextCore.getContextManager().addListener(viewerManager);
			MonitorUi.addWindowPartListener(contentOutlineManager);
			perspectiveManager.addManagedPerspective(ITasksUiConstants.ID_PERSPECTIVE_PLANNING);





	public static final String OBFUSCATED_LABEL = "[obfuscated]"; //$NON-NLS-1$

	public static final String ACTIVITY_TRACKING_ENABLED = "org.eclipse.mylyn.monitor.activity.tracking.enabled"; //$NON-NLS-1$

	private IWorkbenchWindow launchingWorkbenchWindow = null;

	private final org.eclipse.jface.util.IPropertyChangeListener PROPERTY_LISTENER = new org.eclipse.jface.util.IPropertyChangeListener() {

		public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {
			if (event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT)
					|| event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED)) {
				updateActivityTimout();
			} else if (event.getProperty().equals(ACTIVITY_TRACKING_ENABLED)) {
				setActivityTrackingEnabled(getPreferenceStore().getBoolean(ACTIVITY_TRACKING_ENABLED));
					activityContextManager.start();
				} else {
					activityContextManager.stop();
				}

			}
		}

	};

	protected IWindowListener WINDOW_LISTENER = new IWindowListener() {

		}
	};

	private boolean activityTrackingEnabled;

	public MonitorUiPlugin() {
		INSTANCE = this;
	}


		getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT, DEFAULT_ACTIVITY_TIMEOUT);
		getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED, true);
		getPreferenceStore().setDefault(ACTIVITY_TRACKING_ENABLED, false);

		this.activityContextManager = new ActivityContextManager(new ArrayList<AbstractUserActivityMonitor>(0));



			updateActivityTimout();

			activityContextManager.start();
			setActivityTrackingEnabled(getPreferenceStore().getBoolean(ACTIVITY_TRACKING_ENABLED));
			}

			getPreferenceStore().addPropertyChangeListener(PROPERTY_LISTENER);


			activityContextManager.setInactivityTimeout(0);
		}
	}

	public void setActivityTrackingEnabled(boolean b) {
		this.activityTrackingEnabled = b;
	}

	public boolean isActivityTrackingEnabled() {
		return activityTrackingEnabled;
	}

}

Return to bug 291084

Lines 21-26 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListToolTip.java (-32 / +16 lines)
21	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
22	import org.eclipse.jface.layout.GridDataFactory;	22	import org.eclipse.jface.layout.GridDataFactory;
23	import org.eclipse.mylyn.commons.core.DateUtil;	23	import org.eclipse.mylyn.commons.core.DateUtil;
		24	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
24	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonFonts;	25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonFonts;
25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;	26	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
26	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;	27	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonUiUtil;
Lines 180-198 Link Here
180	if (element instanceof ScheduledTaskContainer) {	181	if (element instanceof ScheduledTaskContainer) {
181	ScheduledTaskContainer container = (ScheduledTaskContainer) element;	182	ScheduledTaskContainer container = (ScheduledTaskContainer) element;
182	int estimateTotal = 0;	183	int estimateTotal = 0;
183	long elapsedTotal = 0;	184	long activeTotal = 0;
184	for (ITask child : container.getChildren()) {	185	for (ITask child : container.getChildren()) {
185	if (child instanceof AbstractTask) {	186	if (child instanceof AbstractTask) {
186	estimateTotal += ((AbstractTask) child).getEstimatedTimeHours();	187	estimateTotal += ((AbstractTask) child).getEstimatedTimeHours();
187	elapsedTotal += TasksUiPlugin.getTaskActivityManager().getElapsedTime(child,	188	activeTotal += TasksUiPlugin.getTaskActivityManager().getElapsedTime(child,
188	container.getDateRange());	189	container.getDateRange());
189	}	190	}
190	}	191	}
191	StringBuilder sb = new StringBuilder();	192	StringBuilder sb = new StringBuilder();
192	sb.append(NLS.bind(Messages.TaskListToolTip_Estimate, estimateTotal));	193	appendEstimateAndActive(sb, estimateTotal, activeTotal);
193	sb.append("\n"); //$NON-NLS-1$
194	sb.append(NLS.bind(Messages.TaskListToolTip_Elapsed, DateUtil.getFormattedDurationShort(elapsedTotal)));
195	sb.append("\n"); //$NON-NLS-1$
196	return sb.toString();	194	return sb.toString();
197	} else if (element instanceof ITask) {	195	} else if (element instanceof ITask) {
198	ITask task = (ITask) element;	196	ITask task = (ITask) element;
Lines 232-237 Link Here
232	}	230	}
233	}	231	}
234		232
		233	private void appendEstimateAndActive(StringBuilder sb, int estimateTotal, long activeTotal) {
		234	if (!MonitorUiPlugin.getDefault().isActivityTrackingEnabled()) {
		235	return;
		236	}
		237
		238	sb.append(NLS.bind(Messages.TaskListToolTip_Estimate, estimateTotal));
		239	sb.append("\n"); //$NON-NLS-1$
		240	sb.append(NLS.bind(Messages.TaskListToolTip_Active_X, DateUtil.getFormattedDurationShort(activeTotal)));
		241	sb.append("\n"); //$NON-NLS-1$
		242	}
		243
235	private String getRepositoryLabel(String repositoryKind, String repositoryUrl) {	244	private String getRepositoryLabel(String repositoryKind, String repositoryUrl) {
236	TaskRepository repository = TasksUi.getRepositoryManager().getRepository(repositoryKind, repositoryUrl);	245	TaskRepository repository = TasksUi.getRepositoryManager().getRepository(repositoryKind, repositoryUrl);
237	if (repository != null) {	246	if (repository != null) {
Lines 245-272 Link Here
245	}	254	}
246		255
247	private String getActivityText(IRepositoryElement element) {	256	private String getActivityText(IRepositoryElement element) {
248	// if (element instanceof ScheduledTaskDelegate) {
249	// ScheduledTaskDelegate task = (ScheduledTaskDelegate) element;
250	//
251	// StringBuilder sb = new StringBuilder();
252	// Date date = task.getScheduledForDate();
253	// if (date != null) {
254	// sb.append("Scheduled for: ");
255	// sb.append(new SimpleDateFormat("E").format(date)).append(", ");
256	// sb.append(DateFormat.getDateInstance(DateFormat.LONG).format(date));
257	// sb.append(" (").append(DateFormat.getTimeInstance(DateFormat.SHORT).format(date)).append(")\n");
258	// }
259	//
260	// long elapsed = TasksUiPlugin.getTaskActivityManager().getElapsedTime(task.getCorrespondingTask(),
261	// task.getDateRangeContainer().getStart(), task.getDateRangeContainer().getEnd());
262	// String elapsedTimeString = DateUtil.getFormattedDurationShort(elapsed);
263	// sb.append("Elapsed: ");
264	// sb.append(elapsedTimeString);
265	// sb.append("\n");
266	//
267	// return sb.toString();
268	// } else
269	//
270	if (element instanceof ITask) {	257	if (element instanceof ITask) {
271	AbstractTask task = (AbstractTask) element;	258	AbstractTask task = (AbstractTask) element;
272		259
Lines 286-296 Link Here
286	sb.append(NLS.bind(Messages.TaskListToolTip_Scheduled, scheduledDate.toString()));	273	sb.append(NLS.bind(Messages.TaskListToolTip_Scheduled, scheduledDate.toString()));
287	sb.append("\n"); //$NON-NLS-1$	274	sb.append("\n"); //$NON-NLS-1$
288	}	275	}
289
290	long elapsed = TasksUiPlugin.getTaskActivityManager().getElapsedTime(task);	276	long elapsed = TasksUiPlugin.getTaskActivityManager().getElapsedTime(task);
291	sb.append(NLS.bind(Messages.TaskListToolTip_Elapsed, DateUtil.getFormattedDurationShort(elapsed)));	277	appendEstimateAndActive(sb, (task).getEstimatedTimeHours(), elapsed);
292	sb.append("\n"); //$NON-NLS-1$
293
294	return sb.toString();	278	return sb.toString();
295	}	279	}
296	return null;	280	return null;

Lines 99-104 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/preferences/TasksUiPreferencePage.java (-235 / +58 lines)
99		99
100	private Combo weekStartCombo;	100	private Combo weekStartCombo;
101		101
		102	private Button activityTrackingEnabledButton;
		103
		104	private Label timeoutLabel1;
		105
		106	private Label timeoutLabel2;
		107
102	public TasksUiPreferencePage() {	108	public TasksUiPreferencePage() {
103	super();	109	super();
104	setPreferenceStore(TasksUiPlugin.getDefault().getPreferenceStore());	110	setPreferenceStore(TasksUiPlugin.getDefault().getPreferenceStore());
Lines 112-131 Link Here
112	GridLayout layout = new GridLayout(1, false);	118	GridLayout layout = new GridLayout(1, false);
113	container.setLayout(layout);	119	container.setLayout(layout);
114		120
115	if (getContainer() instanceof IWorkbenchPreferenceContainer) {
116	String message = Messages.TasksUiPreferencePage_See_X_for_configuring_Task_List_colors;
117	new PreferenceLinkArea(container, SWT.NONE, "org.eclipse.ui.preferencePages.ColorsAndFonts", message, //$NON-NLS-1$
118	(IWorkbenchPreferenceContainer) getContainer(), null);
119	}
120
121	createTaskRefreshScheduleGroup(container);	121	createTaskRefreshScheduleGroup(container);
122	createSchedulingGroup(container);	122	createSchedulingGroup(container);
123	createOpenWith(container);	123	createOpenWith(container);
		124	createTaskActivityGroup(container);
124	Composite advanced = createAdvancedSection(container);	125	Composite advanced = createAdvancedSection(container);
125	createTaskActivityGroup(advanced);
126	createTaskDataControl(advanced);	126	createTaskDataControl(advanced);
127	createLinks(container);
128		127
		128	if (getContainer() instanceof IWorkbenchPreferenceContainer) {
		129	String message = Messages.TasksUiPreferencePage_See_X_for_configuring_Task_List_colors;
		130	new PreferenceLinkArea(advanced, SWT.NONE, "org.eclipse.ui.preferencePages.ColorsAndFonts", message, //$NON-NLS-1$
		131	(IWorkbenchPreferenceContainer) getContainer(), null);
		132	}
		133
		134	createLinks(advanced);
129	updateRefreshGroupEnablements();	135	updateRefreshGroupEnablements();
130	applyDialogFont(container);	136	applyDialogFont(container);
131	return container;	137	return container;
Lines 199-205 Link Here
199	timeoutEnabledButton.getSelection());	205	timeoutEnabledButton.getSelection());
200	MonitorUiPlugin.getDefault().getPreferenceStore().setValue(ActivityContextManager.ACTIVITY_TIMEOUT,	206	MonitorUiPlugin.getDefault().getPreferenceStore().setValue(ActivityContextManager.ACTIVITY_TIMEOUT,
201	timeoutMinutes.getSelection() * (60 * 1000));	207	timeoutMinutes.getSelection() * (60 * 1000));
202	//backupNow.setEnabled(true);	208
		209	MonitorUiPlugin.getDefault().getPreferenceStore().setValue(MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED,
		210	activityTrackingEnabledButton.getSelection());
203		211
204	String taskDirectory = taskDirectoryText.getText();	212	String taskDirectory = taskDirectoryText.getText();
205	taskDirectory = taskDirectory.replaceAll(BACKSLASH_MULTI, FORWARDSLASH);	213	taskDirectory = taskDirectory.replaceAll(BACKSLASH_MULTI, FORWARDSLASH);
Lines 262-267 Link Here
262	timeoutMinutes.setSelection(minutes);	270	timeoutMinutes.setSelection(minutes);
263	timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(	271	timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
264	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));	272	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));
		273
		274	activityTrackingEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
		275	MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED));
		276
265	return true;	277	return true;
266	}	278	}
267		279
Lines 306-311 Link Here
306	timeoutMinutes.setSelection(activityTimeoutMinutes);	318	timeoutMinutes.setSelection(activityTimeoutMinutes);
307	timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getDefaultBoolean(	319	timeoutEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getDefaultBoolean(
308	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));	320	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED));
		321
		322	activityTrackingEnabledButton.setSelection(MonitorUiPlugin.getDefault().getPreferenceStore().getDefaultBoolean(
		323	MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED));
		324
309	updateRefreshGroupEnablements();	325	updateRefreshGroupEnablements();
310	}	326	}
311		327
Lines 413-466 Link Here
413		429
414	if (taskDataDirectoryAction != IDialogConstants.CANCEL_ID) {	430	if (taskDataDirectoryAction != IDialogConstants.CANCEL_ID) {
415	taskDirectoryText.setText(dir);	431	taskDirectoryText.setText(dir);
416	// backupFolderText.setText(dir + FORWARDSLASH + ITasksCoreConstants.DEFAULT_BACKUP_FOLDER_NAME);
417	// backupNow.setEnabled(false);
418	}	432	}
419	}	433	}
420		434
421	});	435	});
422		436
423	// Composite backupComposite = new Composite(taskDataGroup, SWT.NULL);
424	// gridLayout = new GridLayout(5, false);
425	// gridLayout.marginWidth = 0;
426	// gridLayout.marginHeight = 0;
427	// backupComposite.setLayout(gridLayout);
428	// backupComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
429
430	// label = new Label(backupComposite, SWT.NULL);
431	// label.setText("Backup every");
432	// backupScheduleTimeText = new Text(backupComposite, SWT.BORDER \| SWT.RIGHT);
433	// final GridData gridData_1 = new GridData();
434	// gridData_1.widthHint = 13;
435	// backupScheduleTimeText.setLayoutData(gridData_1);
436	//
437	// backupScheduleTimeText.setText("" + getPreferenceStore().getInt(TasksUiPreferenceConstants.BACKUP_SCHEDULE));
438	// backupScheduleTimeText.addModifyListener(new ModifyListener() {
439	// public void modifyText(ModifyEvent e) {
440	// updateRefreshGroupEnablements();
441	// }
442	// });
443	//
444	// label = new Label(backupComposite, SWT.NONE);
445	// label.setText("days to");
446
447	// String backupDirectory = TasksUiPlugin.getDefault().getBackupFolderPath();// getPreferenceStore().getString(TaskListPreferenceConstants.BACKUP_FOLDER);
448	// backupDirectory = backupDirectory.replaceAll(BACKSLASH_MULTI, FORWARDSLASH);
449	// backupFolderText = new Text(backupComposite, SWT.BORDER);
450	// backupFolderText.setText(backupDirectory);
451	// backupFolderText.setEditable(false);
452	// backupFolderText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
453	//
454	// backupNow = new Button(backupComposite, SWT.NONE);
455	// backupNow.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END));
456	// backupNow.setText("Backup Now");
457	// backupNow.addSelectionListener(new SelectionAdapter() {
458	//
459	// @Override
460	// public void widgetSelected(SelectionEvent e) {
461	// TasksUiPlugin.getBackupManager().backupNow(true);
462	// }
463	// });
464	}	437	}
465		438
466	private void createSchedulingGroup(Composite container) {	439	private void createSchedulingGroup(Composite container) {
Lines 485-555 Link Here
485	weekStartCombo.add(CommonMessages.Saturday);	458	weekStartCombo.add(CommonMessages.Saturday);
486	weekStartCombo.select(getPreferenceStore().getInt(ITasksUiPreferenceConstants.WEEK_START_DAY) - 1);	459	weekStartCombo.select(getPreferenceStore().getInt(ITasksUiPreferenceConstants.WEEK_START_DAY) - 1);
487		460
488	// Label workWeekBeginLabel = new Label(group, SWT.NONE);
489	// workWeekBeginLabel.setText(START_DAY_LABEL);
490	// workWeekBegin = new Combo(group, SWT.READ_ONLY);
491	// // Calendar.SUNDAY = 1
492	// workWeekBegin.add("SUNDAY");
493	// workWeekBegin.add("MONDAY");
494	// workWeekBegin.add("TUESDAY");
495	// workWeekBegin.add("WEDNESDAY");
496	// workWeekBegin.add("THURSDAY");
497	// workWeekBegin.add("FRIDAY");
498	// workWeekBegin.add("SATURDAY");
499	// workWeekBegin.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_STARTDAY)
500	// - 1);
501
502	// Label workWeekEndLabel = new Label(group, SWT.NONE);
503	// workWeekEndLabel.setText(END_DAY_LABEL);
504	// workWeekEnd = new Combo(group, SWT.READ_ONLY);
505	// workWeekEnd.add("SUNDAY");
506	// workWeekEnd.add("MONDAY");
507	// workWeekEnd.add("TUESDAY");
508	// workWeekEnd.add("WEDNESDAY");
509	// workWeekEnd.add("THURSDAY");
510	// workWeekEnd.add("FRIDAY");
511	// workWeekEnd.add("SATURDAY");
512	// workWeekEnd.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_ENDDAY)
513	// - 1);
514
515	// Label hourDayStartLabel = new Label(group, SWT.NONE);
516	// hourDayStartLabel.setText(START_HOUR_LABEL);
517	// hourDayStart = new Spinner(group, SWT.BORDER);
518	// hourDayStart.setDigits(0);
519	// hourDayStart.setIncrement(1);
520	// hourDayStart.setMaximum(23);
521	// hourDayStart.setMinimum(0);
522	// hourDayStart.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_STARTHOUR));
523	// hourDayStart.addSelectionListener(new SelectionAdapter() {
524	//
525	// @Override
526	// public void widgetSelected(SelectionEvent e) {
527	// updateRefreshGroupEnablements();
528	// }
529	//
530	// });
531	//
532	// Label spacer = new Label(group, SWT.NONE);
533	// GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
534	//
535	// Label hourDayEndLabel = new Label(group, SWT.NONE);
536	// hourDayEndLabel.setText(END_HOUR_LABEL);
537	//
538	// hourDayEnd = new Spinner(group, SWT.BORDER);
539	// hourDayEnd.setDigits(0);
540	// hourDayEnd.setIncrement(1);
541	// hourDayEnd.setMaximum(23);
542	// hourDayEnd.setMinimum(0);
543	// hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
544	// hourDayEnd.addSelectionListener(new SelectionAdapter() {
545	//
546	// @Override
547	// public void widgetSelected(SelectionEvent e) {
548	// updateRefreshGroupEnablements();
549	// }
550	//
551	// });
552
553	}	461	}
554		462
555	private void createTaskActivityGroup(Composite container) {	463	private void createTaskActivityGroup(Composite container) {
Lines 558-566 Link Here
558	group.setLayout(new GridLayout(3, false));	466	group.setLayout(new GridLayout(3, false));
559	group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));	467	group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
560		468
		469	boolean activityTrackingEnabled = MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
		470	MonitorUiPlugin.ACTIVITY_TRACKING_ENABLED);
		471
561	boolean timeoutEnabled = MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(	472	boolean timeoutEnabled = MonitorUiPlugin.getDefault().getPreferenceStore().getBoolean(
562	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED);	473	ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED);
563		474
		475	activityTrackingEnabledButton = new Button(group, SWT.CHECK);
		476	activityTrackingEnabledButton.setText(Messages.TasksUiPreferencePage_Enable_Time_Tracking);
		477	activityTrackingEnabledButton.setSelection(activityTrackingEnabled);
		478	activityTrackingEnabledButton.setToolTipText(Messages.TasksUiPreferencePage_Track_Time_Spent);
		479	activityTrackingEnabledButton.addSelectionListener(new SelectionAdapter() {
		480	@Override
		481	public void widgetSelected(SelectionEvent e) {
		482	updateRefreshGroupEnablements();
		483	}
		484	});
		485	GridDataFactory.swtDefaults().span(3, 1).applyTo(activityTrackingEnabledButton);
		486
564	timeoutEnabledButton = new Button(group, SWT.CHECK);	487	timeoutEnabledButton = new Button(group, SWT.CHECK);
565	timeoutEnabledButton.setText(Messages.TasksUiPreferencePage_Enable_inactivity_timeouts);	488	timeoutEnabledButton.setText(Messages.TasksUiPreferencePage_Enable_inactivity_timeouts);
566	timeoutEnabledButton.setSelection(timeoutEnabled);	489	timeoutEnabledButton.setSelection(timeoutEnabled);
Lines 573-580 Link Here
573	});	496	});
574	GridDataFactory.swtDefaults().span(3, 1).applyTo(timeoutEnabledButton);	497	GridDataFactory.swtDefaults().span(3, 1).applyTo(timeoutEnabledButton);
575		498
576	Label timeoutLabel = new Label(group, SWT.NONE);	499	timeoutLabel1 = new Label(group, SWT.NONE);
577	timeoutLabel.setText(Messages.TasksUiPreferencePage_Stop_time_accumulation_after);	500	timeoutLabel1.setText(Messages.TasksUiPreferencePage_Stop_time_accumulation_after);
578	timeoutMinutes = new Spinner(group, SWT.BORDER);	501	timeoutMinutes = new Spinner(group, SWT.BORDER);
579	timeoutMinutes.setDigits(0);	502	timeoutMinutes.setDigits(0);
580	timeoutMinutes.setIncrement(5);	503	timeoutMinutes.setIncrement(5);
Lines 593-711 Link Here
593		516
594	});	517	});
595		518
596	timeoutLabel = new Label(group, SWT.NONE);	519	timeoutLabel2 = new Label(group, SWT.NONE);
597	timeoutLabel.setText(Messages.TasksUiPreferencePage_minutes_of_inactivity);	520	timeoutLabel2.setText(Messages.TasksUiPreferencePage_minutes_of_inactivity);
598		521
599	// Label spacer = new Label(group, SWT.NONE);	522	}
600	// GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
601	//
602	// Label hourDayEndLabel = new Label(group, SWT.NONE);
603	// hourDayEndLabel.setText(END_HOUR_LABEL);
604	//
605	// hourDayEnd = new Spinner(group, SWT.BORDER);
606	// hourDayEnd.setDigits(0);
607	// hourDayEnd.setIncrement(1);
608	// hourDayEnd.setMaximum(23);
609	// hourDayEnd.setMinimum(0);
610	// hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
611	// hourDayEnd.addSelectionListener(new SelectionAdapter() {
612	//
613	// @Override
614	// public void widgetSelected(SelectionEvent e) {
615	// updateRefreshGroupEnablements();
616	// }
617	//
618	// });
619
620	}
621
622	// private void createSchedulingGroup(Composite container) {
623	// Group group = new Group(container, SWT.SHADOW_ETCHED_IN);
624	// group.setText(GROUP_WORK_WEEK_LABEL);
625	// group.setLayout(new GridLayout(5, false));
626	// group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
627	//
628	// // Label workWeekBeginLabel = new Label(group, SWT.NONE);
629	// // workWeekBeginLabel.setText(START_DAY_LABEL);
630	// // workWeekBegin = new Combo(group, SWT.READ_ONLY);
631	// // // Calendar.SUNDAY = 1
632	// // workWeekBegin.add("SUNDAY");
633	// // workWeekBegin.add("MONDAY");
634	// // workWeekBegin.add("TUESDAY");
635	// // workWeekBegin.add("WEDNESDAY");
636	// // workWeekBegin.add("THURSDAY");
637	// // workWeekBegin.add("FRIDAY");
638	// // workWeekBegin.add("SATURDAY");
639	// // workWeekBegin.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_STARTDAY)
640	// // - 1);
641	// //
642	// // Label workWeekEndLabel = new Label(group, SWT.NONE);
643	// // workWeekEndLabel.setText(END_DAY_LABEL);
644	// // workWeekEnd = new Combo(group, SWT.READ_ONLY);
645	// // workWeekEnd.add("SUNDAY");
646	// // workWeekEnd.add("MONDAY");
647	// // workWeekEnd.add("TUESDAY");
648	// // workWeekEnd.add("WEDNESDAY");
649	// // workWeekEnd.add("THURSDAY");
650	// // workWeekEnd.add("FRIDAY");
651	// // workWeekEnd.add("SATURDAY");
652	// // workWeekEnd.select(getPreferenceStore().getInt(TaskListPreferenceConstants.PLANNING_ENDDAY)
653	// // - 1);
654	//
655	// Label hourDayStartLabel = new Label(group, SWT.NONE);
656	// hourDayStartLabel.setText(START_HOUR_LABEL);
657	// hourDayStart = new Spinner(group, SWT.BORDER);
658	// hourDayStart.setDigits(0);
659	// hourDayStart.setIncrement(1);
660	// hourDayStart.setMaximum(23);
661	// hourDayStart.setMinimum(0);
662	// hourDayStart.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_STARTHOUR));
663	// hourDayStart.addSelectionListener(new SelectionAdapter() {
664	//
665	// @Override
666	// public void widgetSelected(SelectionEvent e) {
667	// updateRefreshGroupEnablements();
668	// }
669	//
670	// });
671	//
672	// Label spacer = new Label(group, SWT.NONE);
673	// GridDataFactory.fillDefaults().hint(40, SWT.DEFAULT).applyTo(spacer);
674	//
675	// Label hourDayEndLabel = new Label(group, SWT.NONE);
676	// hourDayEndLabel.setText(END_HOUR_LABEL);
677	//
678	// hourDayEnd = new Spinner(group, SWT.BORDER);
679	// hourDayEnd.setDigits(0);
680	// hourDayEnd.setIncrement(1);
681	// hourDayEnd.setMaximum(23);
682	// hourDayEnd.setMinimum(0);
683	// hourDayEnd.setSelection(getPreferenceStore().getInt(TasksUiPreferenceConstants.PLANNING_ENDHOUR));
684	// hourDayEnd.addSelectionListener(new SelectionAdapter() {
685	//
686	// @Override
687	// public void widgetSelected(SelectionEvent e) {
688	// updateRefreshGroupEnablements();
689	// }
690	//
691	// });
692	//
693	// }
694		523
695	public void updateRefreshGroupEnablements() {	524	public void updateRefreshGroupEnablements() {
696	String errorMessage = null;	525	String errorMessage = null;
697		526
698	// try {
699	// long number = Integer.parseInt(backupScheduleTimeText.getText());
700	// if (number <= 0) {
701	// errorMessage = "Backup schedule time must be > 0";
702	// } else if (backupFolderText.getText() == "") {
703	// errorMessage = "Backup destination folder must be specified";
704	// }
705	// } catch (NumberFormatException e) {
706	// errorMessage = "Backup schedule time must be valid integer";
707	// }
708
709	if (enableBackgroundSynch.getSelection()) {	527	if (enableBackgroundSynch.getSelection()) {
710	try {	528	try {
711	long number = Long.parseLong(synchScheduleTime.getText());	529	long number = Long.parseLong(synchScheduleTime.getText());
Lines 717-733 Link Here
717	}	535	}
718	}	536	}
719		537
720	// if (hourDayEnd.getSelection() <= hourDayStart.getSelection()) {
721	// errorMessage = "Planning: Work day start must be before end.";
722	// }
723
724	setErrorMessage(errorMessage);	538	setErrorMessage(errorMessage);
725	setValid(errorMessage == null);	539	setValid(errorMessage == null);
726		540
727	synchScheduleTime.setEnabled(enableBackgroundSynch.getSelection());	541	if (activityTrackingEnabledButton.getSelection()) {
728		542	timeoutEnabledButton.setEnabled(true);
729	timeoutMinutes.setEnabled(timeoutEnabledButton.getSelection());	543	synchScheduleTime.setEnabled(enableBackgroundSynch.getSelection());
730		544	timeoutMinutes.setEnabled(timeoutEnabledButton.getSelection());
		545	timeoutLabel1.setEnabled(timeoutEnabledButton.getSelection());
		546	timeoutLabel2.setEnabled(timeoutEnabledButton.getSelection());
		547	} else {
		548	timeoutEnabledButton.setEnabled(false);
		549	synchScheduleTime.setEnabled(false);
		550	timeoutMinutes.setEnabled(false);
		551	timeoutLabel1.setEnabled(false);
		552	timeoutLabel2.setEnabled(false);
		553	}
731	}	554	}
732		555
733	private String getMinutesString() {	556	private String getMinutesString() {

Lines 16-21 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/preferences/messages.properties (-1 / +3 lines)
16	TasksUiPreferencePage_Destination_folder_does_not_exist=Destination folder does not exist.	16	TasksUiPreferencePage_Destination_folder_does_not_exist=Destination folder does not exist.
17	TasksUiPreferencePage_Display_notifications_for_overdue_tasks_and_incoming_changes=Display notifications for overdue tasks and incoming changes	17	TasksUiPreferencePage_Display_notifications_for_overdue_tasks_and_incoming_changes=Display notifications for overdue tasks and incoming changes
18	TasksUiPreferencePage_Enable_inactivity_timeouts=Enable inactivity timeouts	18	TasksUiPreferencePage_Enable_inactivity_timeouts=Enable inactivity timeouts
		19	TasksUiPreferencePage_Enable_Time_Tracking=Track time spent within Eclipse when a task is active
19	TasksUiPreferencePage_Error_applying_Task_List_data_directory_changes=Error applying Task List data directory changes. The previous setting will be restored.	20	TasksUiPreferencePage_Error_applying_Task_List_data_directory_changes=Error applying Task List data directory changes. The previous setting will be restored.
20	TasksUiPreferencePage_Folder_Selection=Folder Selection	21	TasksUiPreferencePage_Folder_Selection=Folder Selection
21	TasksUiPreferencePage_If_disabled=If disabled, time accumulates while a task is active with no timeout due to inactivity.	22	TasksUiPreferencePage_If_disabled=If disabled, time accumulates while a task is active with no timeout due to inactivity.
Lines 34-40 Link Here
34	TasksUiPreferencePage_Task_Data=Task Data	35	TasksUiPreferencePage_Task_Data=Task Data
35	TasksUiPreferencePage_Task_Data_Directory_Error=Task Data Directory Error	36	TasksUiPreferencePage_Task_Data_Directory_Error=Task Data Directory Error
36	TasksUiPreferencePage_Task_Editing=Task Editing	37	TasksUiPreferencePage_Task_Editing=Task Editing
37	TasksUiPreferencePage_Task_Timing=Task Timing	38	TasksUiPreferencePage_Task_Timing=Time Tracking
		39	TasksUiPreferencePage_Track_Time_Spent=Track time spent within Eclipse when a task is active
38	TasksUiPreferencePage_Use_the_Restore_dialog_to_recover_missing_tasks=Use the Restore dialog to recover missing tasks	40	TasksUiPreferencePage_Use_the_Restore_dialog_to_recover_missing_tasks=Use the Restore dialog to recover missing tasks
39	TasksUiPreferencePage_Web_Browser=Web Browser	41	TasksUiPreferencePage_Web_Browser=Web Browser
40	TasksUiPreferencePage_Week_Start=Week Start:	42	TasksUiPreferencePage_Week_Start=Week Start:

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskActivationExternalizationParticipant.java (+162 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Tasktop Technologies and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Tasktop Technologies - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.tasks.ui;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.FileWriter;
17	import java.io.IOException;
18
19	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.core.runtime.IProgressMonitor;
21	import org.eclipse.core.runtime.IStatus;
22	import org.eclipse.core.runtime.Status;
23	import org.eclipse.core.runtime.jobs.ISchedulingRule;
24	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
25	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
26	import org.eclipse.mylyn.internal.tasks.core.TaskActivationHistory;
27	import org.eclipse.mylyn.internal.tasks.core.TaskList;
28	import org.eclipse.mylyn.internal.tasks.core.externalization.AbstractExternalizationParticipant;
29	import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;
30	import org.eclipse.mylyn.tasks.core.ITask;
31	import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
32	import org.eclipse.ui.IMemento;
33	import org.eclipse.ui.XMLMemento;
34
35	/**
36	* @author Steffen Pingel
37	*/
38	public class TaskActivationExternalizationParticipant extends AbstractExternalizationParticipant implements
39	ITaskActivationListener {
40
41	private final ExternalizationManager externalizationManager;
42
43	private boolean dirty;
44
45	private final TaskActivationHistory activationHistory;
46
47	private final File file;
48
49	private final TaskList taskList;
50
51	public TaskActivationExternalizationParticipant(ExternalizationManager externalizationManager, TaskList taskList,
52	TaskActivationHistory history, File file) {
53	this.externalizationManager = externalizationManager;
54	this.taskList = taskList;
55	this.activationHistory = history;
56	this.file = file;
57	}
58
59	@Override
60	public String getDescription() {
61	return Messages.TaskActivationExternalizationParticipant_Task_Activation_History;
62	}
63
64	@Override
65	public ISchedulingRule getSchedulingRule() {
66	return ITasksCoreConstants.ACTIVITY_SCHEDULING_RULE;
67	}
68
69	@Override
70	public boolean isDirty() {
71	return dirty;
72	}
73
74	private void requestSave() {
75	synchronized (TaskActivationExternalizationParticipant.this) {
76	dirty = true;
77	}
78	externalizationManager.requestSave();
79	}
80
81	@Override
82	public void load(File sourceFile, IProgressMonitor monitor) throws CoreException {
83	try {
84	activationHistory.clear();
85	if (file.exists()) {
86	FileReader reader = new FileReader(file);
87	try {
88	XMLMemento memento = XMLMemento.createReadRoot(reader);
89	IMemento[] items = memento.getChildren("task"); //$NON-NLS-1$
90	for (IMemento child : items) {
91	String handle = child.getString("handle"); //$NON-NLS-1$
92	if (handle != null) {
93	AbstractTask task = taskList.getTask(handle);
94	if (task != null) {
95	activationHistory.addTaskInternal(task);
96	}
97	}
98	}
99	} finally {
100	reader.close();
101	}
102	}
103	} catch (IOException e) {
104	throw new CoreException(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
105	"Failed to load task activation history", e)); //$NON-NLS-1$
106	}
107	}
108
109	@Override
110	public void save(File targetFile, IProgressMonitor monitor) throws CoreException {
111	synchronized (TaskActivationExternalizationParticipant.this) {
112	dirty = false;
113	}
114
115	XMLMemento memento = XMLMemento.createWriteRoot("taskActivationHistory"); //$NON-NLS-1$
116	for (AbstractTask task : activationHistory.getPreviousTasks()) {
117	IMemento child = memento.createChild("task"); //$NON-NLS-1$
118	child.putString("handle", task.getHandleIdentifier()); //$NON-NLS-1$
119	}
120
121	try {
122	file.getParentFile().mkdirs();
123	FileWriter writer = new FileWriter(file);
124	try {
125	memento.save(writer);
126	} finally {
127	writer.close();
128	}
129	} catch (IOException e) {
130	throw new CoreException(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
131	"Failed to save task activation history", e)); //$NON-NLS-1$
132	}
133	}
134
135	@Override
136	public String getFileName() {
137	return file.getName();
138	}
139
140	@Override
141	public File getFile(String rootPath) throws CoreException {
142	return file;
143	}
144
145	public void preTaskActivated(ITask task) {
146	// ignore
147	}
148
149	public void preTaskDeactivated(ITask task) {
150	// ignore
151	}
152
153	public void taskActivated(ITask task) {
154	activationHistory.addTask((AbstractTask) task);
155	requestSave();
156	}
157
158	public void taskDeactivated(ITask task) {
159	// ignore
160	}
161
162	}

Lines 42-53 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextUiPlugin.java (-7 / +2 lines)
42	import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;	42	import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
43	import org.eclipse.mylyn.context.core.ContextChangeEvent;	43	import org.eclipse.mylyn.context.core.ContextChangeEvent;
44	import org.eclipse.mylyn.context.core.ContextCore;	44	import org.eclipse.mylyn.context.core.ContextCore;
		45	import org.eclipse.mylyn.context.core.IInteractionContext;
45	import org.eclipse.mylyn.context.core.IInteractionElement;	46	import org.eclipse.mylyn.context.core.IInteractionElement;
46	import org.eclipse.mylyn.context.core.IInteractionRelation;	47	import org.eclipse.mylyn.context.core.IInteractionRelation;
47	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;	48	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
48	import org.eclipse.mylyn.context.ui.IContextUiStartup;	49	import org.eclipse.mylyn.context.ui.IContextUiStartup;
49	import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;	50	import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;
50	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
51	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;	51	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;
52	import org.eclipse.mylyn.monitor.ui.MonitorUi;	52	import org.eclipse.mylyn.monitor.ui.MonitorUi;
53	import org.eclipse.mylyn.tasks.core.ITask;	53	import org.eclipse.mylyn.tasks.core.ITask;
Lines 186-192 Link Here
186		186
187	private static final ITaskActivationListener TASK_ACTIVATION_LISTENER = new TaskActivationAdapter() {	187	private static final ITaskActivationListener TASK_ACTIVATION_LISTENER = new TaskActivationAdapter() {
188		188
189	@SuppressWarnings({ "restriction" })	189	@SuppressWarnings("restriction")
190	@Override	190	@Override
191	public void taskActivated(ITask task) {	191	public void taskActivated(ITask task) {
192	if (CoreUtil.TEST_MODE) {	192	if (CoreUtil.TEST_MODE) {
Lines 243-255 Link Here
243	}	243	}
244	}	244	}
245		245
246	@SuppressWarnings("restriction")
247	private void lazyStart(IWorkbench workbench) {	246	private void lazyStart(IWorkbench workbench) {
248	try {	247	try {
249	MonitorUiPlugin.getDefault()
250	.getPreferenceStore()
251	.setValue(MonitorUiPlugin.PREF_USER_ACTIVITY_ENABLED, true);
252	MonitorUiPlugin.getDefault().savePluginPreferences();
253	ContextCore.getContextManager().addListener(viewerManager);	248	ContextCore.getContextManager().addListener(viewerManager);
254	MonitorUi.addWindowPartListener(contentOutlineManager);	249	MonitorUi.addWindowPartListener(contentOutlineManager);
255	perspectiveManager.addManagedPerspective(ITasksUiConstants.ID_PERSPECTIVE_PLANNING);	250	perspectiveManager.addManagedPerspective(ITasksUiConstants.ID_PERSPECTIVE_PLANNING);

Lines 81-106 Link Here

(-)src/org/eclipse/mylyn/internal/monitor/ui/MonitorUiPlugin.java (-13 / +17 lines)
81		81
82	public static final String OBFUSCATED_LABEL = "[obfuscated]"; //$NON-NLS-1$	82	public static final String OBFUSCATED_LABEL = "[obfuscated]"; //$NON-NLS-1$
83		83
84	public static final String PREF_USER_ACTIVITY_ENABLED = "org.eclipse.mylyn.monitor.user.activity.enabled"; //$NON-NLS-1$	84	public static final String ACTIVITY_TRACKING_ENABLED = "org.eclipse.mylyn.monitor.activity.tracking.enabled"; //$NON-NLS-1$
85		85
86	private IWorkbenchWindow launchingWorkbenchWindow = null;	86	private IWorkbenchWindow launchingWorkbenchWindow = null;
87		87
88	private final org.eclipse.jface.util.IPropertyChangeListener PROPERTY_LISTENER = new org.eclipse.jface.util.IPropertyChangeListener() {	88	private final org.eclipse.jface.util.IPropertyChangeListener PROPERTY_LISTENER = new org.eclipse.jface.util.IPropertyChangeListener() {
89
90	public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {	89	public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {
91	if (event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT)	90	if (event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT)
92	\|\| event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED)) {	91	\|\| event.getProperty().equals(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED)) {
93	updateActivityTimout();	92	updateActivityTimout();
94	} else if (event.getProperty().equals(PREF_USER_ACTIVITY_ENABLED)) {	93	} else if (event.getProperty().equals(ACTIVITY_TRACKING_ENABLED)) {
95	if (getPreferenceStore().getBoolean(PREF_USER_ACTIVITY_ENABLED)) {	94	setActivityTrackingEnabled(getPreferenceStore().getBoolean(ACTIVITY_TRACKING_ENABLED));
96	activityContextManager.start();
97	} else {
98	activityContextManager.stop();
99	}
100
101	}	95	}
102	}	96	}
103
104	};	97	};
105		98
106	protected IWindowListener WINDOW_LISTENER = new IWindowListener() {	99	protected IWindowListener WINDOW_LISTENER = new IWindowListener() {
Lines 135-140 Link Here
135	}	128	}
136	};	129	};
137		130
		131	private boolean activityTrackingEnabled;
		132
138	public MonitorUiPlugin() {	133	public MonitorUiPlugin() {
139	INSTANCE = this;	134	INSTANCE = this;
140	}	135	}
Lines 145-150 Link Here
145		140
146	getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT, DEFAULT_ACTIVITY_TIMEOUT);	141	getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT, DEFAULT_ACTIVITY_TIMEOUT);
147	getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED, true);	142	getPreferenceStore().setDefault(ActivityContextManager.ACTIVITY_TIMEOUT_ENABLED, true);
		143	getPreferenceStore().setDefault(ACTIVITY_TRACKING_ENABLED, false);
148		144
149	this.activityContextManager = new ActivityContextManager(new ArrayList<AbstractUserActivityMonitor>(0));	145	this.activityContextManager = new ActivityContextManager(new ArrayList<AbstractUserActivityMonitor>(0));
150		146
Lines 414-422 Link Here
414		410
415	updateActivityTimout();	411	updateActivityTimout();
416		412
417	if (getPreferenceStore().getBoolean(PREF_USER_ACTIVITY_ENABLED)) {	413	activityContextManager.start();
418	activityContextManager.start();	414	setActivityTrackingEnabled(getPreferenceStore().getBoolean(ACTIVITY_TRACKING_ENABLED));
419	}
420		415
421	getPreferenceStore().addPropertyChangeListener(PROPERTY_LISTENER);	416	getPreferenceStore().addPropertyChangeListener(PROPERTY_LISTENER);
422		417
Lines 433-436 Link Here
433	activityContextManager.setInactivityTimeout(0);	428	activityContextManager.setInactivityTimeout(0);
434	}	429	}
435	}	430	}
		431
		432	public void setActivityTrackingEnabled(boolean b) {
		433	this.activityTrackingEnabled = b;
		434	}
		435
		436	public boolean isActivityTrackingEnabled() {
		437	return activityTrackingEnabled;
		438	}
		439
436	}	440	}