NEW - bug 219665: inconsistent schedule for ui

https://bugs.eclipse.org/bugs/show_bug.cgi?id=219665

6 files changed, 215 insertions, 260 deletions

diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
index a11f8fa50..34b0fc02c 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
@@ -12,7 +12,6 @@ import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.Date;
-import java.util.GregorianCalendar;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -673,7 +672,7 @@ public class TaskActivityManager {
 //		pastStart.setTime(startTime);
 //		pastStart.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PAST_START);
 //		TaskActivityUtil.snapToStartOfWeek(pastStart);
-		GregorianCalendar pastEnd = new GregorianCalendar();
+		Calendar pastEnd = TaskActivityUtil.getStartOfCurrentWeek();
 		pastEnd.setFirstDayOfWeek(startDay);
 		pastEnd.setTime(startTime);
 		pastEnd.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PAST_END);
@@ -860,4 +859,40 @@ public class TaskActivityManager {
 		return getScheduledTasks(startWeek, endWeek);
 	}
 
+	public ScheduledTaskContainer getActivityToday() {
+		for (ScheduledTaskContainer container : scheduleWeekDays) {
+			if (container.isToday()) {
+				return container;
+			}
+		}
+		return null;
+	}
+
+	public ScheduledTaskContainer getActivityContainer(Calendar calendar, boolean isFloating) {
+		if (calendar == null) {
+			return null;
+		}
+		if (isPastReminder(calendar.getTime(), false)) {
+			return getActivityToday();
+		}
+
+		if (!isFloating) {
+			for (ScheduledTaskContainer container : scheduleWeekDays) {
+				if (container.includes(calendar)) {
+					return container;
+				}
+			}
+		} else {
+			if (scheduledThisWeek.includes(calendar)) {
+				return scheduledThisWeek;
+			} else if (scheduledNextWeek.includes(calendar)) {
+				return scheduledNextWeek;
+			} else {
+				return scheduledFuture;
+			}
+		}
+
+		return null;
+	}
+
 }
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleDatePicker.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleDatePicker.java
index b6b276297..cc8bdf999 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleDatePicker.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleDatePicker.java
@@ -17,6 +17,8 @@ import java.util.LinkedList;
 import java.util.List;
 
 import org.eclipse.jface.action.MenuManager;
+import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
+import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
 import org.eclipse.mylyn.tasks.core.AbstractTask;
 import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
 import org.eclipse.mylyn.tasks.ui.DatePicker;
@@ -43,8 +45,7 @@ public class ScheduleDatePicker extends Composite {
 
 	private final List<SelectionListener> pickerListeners = new LinkedList<SelectionListener>();
 
-	private final SimpleDateFormat simpleDateFormat = (SimpleDateFormat) DateFormat.getDateTimeInstance(
-			DateFormat.MEDIUM, DateFormat.SHORT);
+	private final SimpleDateFormat simpleDateFormat = (SimpleDateFormat) DateFormat.getDateInstance(DateFormat.MEDIUM);
 
 	private final String initialText = DatePicker.LABEL_CHOOSE;
 
@@ -54,13 +55,22 @@ public class ScheduleDatePicker extends Composite {
 
 	private Date scheduledDate;
 
-	private boolean isFloating;
+	private boolean isFloating = false;
+
+	private ScheduledTaskContainer scheduledContainer;
 
 	public ScheduleDatePicker(Composite parent, AbstractTask task, int style) {
 		super(parent, style);
-		this.scheduledDate = task.getScheduledForDate();
-		this.isFloating = task.internalIsFloatingScheduledDate();
-		this.setDatePattern("yyyy-MM-dd");
+		if (task != null) {
+			if (task.getScheduledForDate() != null) {
+				Calendar cal = TaskActivityUtil.getCalendar();
+				cal.setTime(task.getScheduledForDate());
+				scheduledContainer = TasksUiPlugin.getTaskActivityManager().getActivityContainer(cal, isFloating);
+				this.scheduledDate = task.getScheduledForDate();
+			}
+			this.isFloating = task.internalIsFloatingScheduledDate();
+		}
+
 		initialize((style & SWT.FLAT) > 0 ? SWT.FLAT : 0);
 		contributor = new ScheduleTaskMenuContributor() {
 
@@ -75,13 +85,16 @@ public class ScheduleDatePicker extends Composite {
 			}
 
 			@Override
-			protected void setScheduledDate(AbstractTask task, Calendar scheduledDate, boolean floating) {
-				if (scheduledDate != null) {
-					ScheduleDatePicker.this.scheduledDate = scheduledDate.getTime();
+			protected void setScheduledDate(ScheduledTaskContainer container) {
+				if (container != null) {
+					scheduledContainer = container;
+					ScheduleDatePicker.this.scheduledDate = container.getStart().getTime();
+					ScheduleDatePicker.this.isFloating = container.isCaptureFloating();
 				} else {
+					scheduledContainer = null;
 					ScheduleDatePicker.this.scheduledDate = null;
+					ScheduleDatePicker.this.isFloating = false;
 				}
-				ScheduleDatePicker.this.isFloating = floating;
 				updateDateText();
 				notifyPickerListeners();
 			}
@@ -124,7 +137,6 @@ public class ScheduleDatePicker extends Composite {
 				Menu menu = menuManager.createContextMenu(pickButton);
 				pickButton.setMenu(menu);
 				menu.setVisible(true);
-
 			}
 		});
 
@@ -150,7 +162,11 @@ public class ScheduleDatePicker extends Composite {
 
 	private void updateDateText() {
 		if (scheduledDate != null) {
-			scheduledDateText.setText(simpleDateFormat.format(scheduledDate));
+			if (scheduledContainer != null && !scheduledContainer.getSummary().equals("")) {
+				scheduledDateText.setText(scheduledContainer.getSummary());
+			} else {
+				scheduledDateText.setText(simpleDateFormat.format(scheduledDate));
+			}
 		} else {
 			scheduledDateText.setEnabled(false);
 			scheduledDateText.setText(DatePicker.LABEL_CHOOSE);
@@ -169,7 +185,15 @@ public class ScheduleDatePicker extends Composite {
 		return scheduledDate;
 	}
 
-	public void setScheduledDate(Date date) {
+	public void setScheduledDate(Date date, boolean isFloating) {
+		if (date != null) {
+			Calendar cal = TaskActivityUtil.getCalendar();
+			cal.setTime(date);
+			scheduledContainer = TasksUiPlugin.getTaskActivityManager().getActivityContainer(cal, isFloating);
+			this.isFloating = isFloating;
+		} else {
+			scheduledContainer = null;
+		}
 		scheduledDate = date;
 		updateDateText();
 	}
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleTaskMenuContributor.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleTaskMenuContributor.java
index 9096f1e5c..a107a7df4 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleTaskMenuContributor.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/ScheduleTaskMenuContributor.java
@@ -16,7 +16,9 @@ import java.util.List;
 import org.eclipse.jface.action.Action;
 import org.eclipse.jface.action.MenuManager;
 import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.resource.ImageDescriptor;
 import org.eclipse.jface.window.Window;
+import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
 import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
 import org.eclipse.mylyn.internal.tasks.ui.planner.DateSelectionDialog;
 import org.eclipse.mylyn.tasks.core.AbstractTask;
@@ -25,202 +27,71 @@ import org.eclipse.mylyn.tasks.ui.DatePicker;
 import org.eclipse.ui.PlatformUI;
 
 /**
- * TODO: this has bloated, refactor
- * 
  * @author Rob Elves
  * @author Mik Kersten
  */
 public class ScheduleTaskMenuContributor implements IDynamicSubMenuContributor {
 
-	private static final String LABEL_THIS_WEEK = "This week";
-
 	private static final String LABEL_REMINDER = "Schedule for";
 
-	private static final String LABEL_TODAY = "Today";
-
-	private static final String LABEL_NEXT_WEEK = "Next Week";
-
-	private static final String LABEL_TWO_WEEKS = "Two Weeks";
-
 	private static final String LABEL_FUTURE = "Future";
 
 	private static final String LABEL_CALENDAR = "Choose Date...";
 
 	private static final String LABEL_NOT_SCHEDULED = "Not Scheduled";
 
-	public MenuManager getSubMenuManager(final List<AbstractTaskContainer> selectedElements) {
+	private AbstractTask singleTaskSelection;
 
-		final TaskListManager tasklistManager = TasksUiPlugin.getTaskListManager();
+	private final List<AbstractTaskContainer> taskListElementsToSchedule = new ArrayList<AbstractTaskContainer>();
 
-		final MenuManager subMenuManager = new MenuManager(LABEL_REMINDER);
+	public MenuManager getSubMenuManager(final List<AbstractTaskContainer> selectedElements) {
 
-		subMenuManager.setVisible(selectedElements.size() > 0 && selectedElements.get(0) instanceof AbstractTask);// !(selectedElements.get(0) instanceof AbstractTaskContainer || selectedElements.get(0) instanceof AbstractRepositoryQuery));
+		final MenuManager subMenuManager = new MenuManager(LABEL_REMINDER);
 
-		AbstractTaskContainer singleSelection = null;
 		if (selectedElements.size() == 1) {
 			AbstractTaskContainer selectedElement = selectedElements.get(0);
 			if (selectedElement instanceof AbstractTask) {
-				singleSelection = selectedElement;
+				singleTaskSelection = (AbstractTask) selectedElement;
 			}
 		}
-		final AbstractTask singleTaskSelection = tasklistManager.getTaskForElement(singleSelection, false);
-		final List<AbstractTaskContainer> taskListElementsToSchedule = new ArrayList<AbstractTaskContainer>();
+
 		for (AbstractTaskContainer selectedElement : selectedElements) {
 			if (selectedElement instanceof AbstractTask) {
 				taskListElementsToSchedule.add(selectedElement);
 			}
 		}
 
-		Action action = new Action() {
-			@Override
-			public void run() {
-				Calendar reminderCalendar = Calendar.getInstance();
-				TaskActivityUtil.snapEndOfWorkDay(reminderCalendar);
-				for (AbstractTaskContainer element : taskListElementsToSchedule) {
-					AbstractTask task = tasklistManager.getTaskForElement(element, true);
-					setScheduledDate(task, reminderCalendar, false);
-				}
-			}
-		};
-		action.setText(LABEL_TODAY);
-		action.setImageDescriptor(TasksUiImages.SCHEDULE_DAY);
-		action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
+		// Today
+		Action action = createDateSelectionAction(TasksUiPlugin.getTaskActivityManager().getActivityToday(),
+				TasksUiImages.SCHEDULE_DAY);
 		subMenuManager.add(action);
 
-		if (singleTaskSelection != null
-				&& (TasksUiPlugin.getTaskActivityManager().isScheduledForToday(
-						getScheduledForDate(singleTaskSelection), isFloating(singleTaskSelection)) || (isPastReminder(singleTaskSelection) && !isFloating(singleTaskSelection)))) {
+		// Special case: Over scheduled tasks always 'scheduled' for today
+		if (singleTaskSelection != null && !isFloating(singleTaskSelection) && isPastReminder(singleTaskSelection)) {
 			action.setChecked(true);
 		}
 
-//		subMenuManager.add(new Separator());
-
-		final int today = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
-		for (int i = today + 1; i <= today + 7; i++) {
-			final int day = i;
-			action = new Action() {
-				@Override
-				public void run() {
-					Calendar reminderCalendar = TaskActivityUtil.getCalendar();
-					int dueIn = day - today;
-					TaskActivityUtil.snapForwardNumDays(reminderCalendar, dueIn);
-					for (AbstractTaskContainer element : taskListElementsToSchedule) {
-						AbstractTask task = tasklistManager.getTaskForElement(element, true);
-						setScheduledDate(task, reminderCalendar, false);
-					}
-				}
-			};
-			getDayLabel(i, action);
-			if (singleTaskSelection != null && getScheduledForDate(singleTaskSelection) != null
-					&& !isFloating(singleTaskSelection)) {
-				Calendar dayStart = Calendar.getInstance();
-				dayStart.add(Calendar.DAY_OF_MONTH, i - today);
-				TaskActivityUtil.snapStartOfDay(dayStart);
-				dayStart.getTime();
-				Calendar dayEnd = Calendar.getInstance();
-				dayEnd.add(Calendar.DAY_OF_MONTH, i - today);
-				TaskActivityUtil.snapEndOfDay(dayEnd);
-				dayEnd.getTime();
-				Calendar time = TaskActivityUtil.getCalendar();
-				time.setTime(getScheduledForDate(singleTaskSelection));
-				if (TaskActivityUtil.isBetween(time, dayStart, dayEnd)) {
-					action.setChecked(true);
-				}
+		// Days of week
+		List<ScheduledTaskContainer> weekDays = TasksUiPlugin.getTaskActivityManager().getActivityWeekDays();
+		for (final ScheduledTaskContainer scheduledTaskContainer : weekDays) {
+			if (scheduledTaskContainer.isFuture()) {
+				action = createDateSelectionAction(scheduledTaskContainer, null);
+				subMenuManager.add(action);
 			}
-			action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
-			subMenuManager.add(action);
 		}
 
 		subMenuManager.add(new Separator());
 
-		action = new Action() {
-			@Override
-			public void run() {
-				Calendar reminderCalendar = TaskActivityUtil.getCalendar();
-				TaskActivityUtil.snapStartOfWorkWeek(reminderCalendar);
-				for (AbstractTaskContainer element : taskListElementsToSchedule) {
-					AbstractTask task = tasklistManager.getTaskForElement(element, true);
-					if (task != null) {
-						setScheduledDate(task, reminderCalendar, true);
-					}
-				}
-			}
-		};
-		action.setText(LABEL_THIS_WEEK);
-		action.setImageDescriptor(TasksUiImages.SCHEDULE_WEEK);
-		action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
+		// This Week
+		action = createDateSelectionAction(TasksUiPlugin.getTaskActivityManager().getActivityThisWeek(),
+				TasksUiImages.SCHEDULE_WEEK);
 		subMenuManager.add(action);
 
-		if (singleTaskSelection != null
-				&& isFloating(singleTaskSelection)
-				&& (TasksUiPlugin.getTaskActivityManager().isScheduledForThisWeek(
-						getScheduledForDate(singleTaskSelection)) || isPastReminder(singleTaskSelection))) {
-			action.setChecked(true);
-		}
-
-		action = new Action() {
-			@Override
-			public void run() {
-				for (AbstractTaskContainer element : taskListElementsToSchedule) {
-					AbstractTask task = tasklistManager.getTaskForElement(element, true);
-					Calendar startNextWeek = Calendar.getInstance();
-					TaskActivityUtil.snapNextWorkWeek(startNextWeek);
-					setScheduledDate(task, startNextWeek, true);
-				}
-			}
-		};
-		action.setText(LABEL_NEXT_WEEK);
-		action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
-
-		if (singleTaskSelection != null
-				&& isFloating(singleTaskSelection)
-				&& TasksUiPlugin.getTaskActivityManager().isScheduledAfterThisWeek(
-						getScheduledForDate(singleTaskSelection))
-				&& !TasksUiPlugin.getTaskActivityManager().isScheduledForFuture(
-						getScheduledForDate(singleTaskSelection))) {
-			action.setChecked(true);
-		}
-
-		subMenuManager.add(action);
-
-		// 2 weeks
-		action = new Action() {
-			@Override
-			public void run() {
-				for (AbstractTaskContainer element : taskListElementsToSchedule) {
-					AbstractTask task = tasklistManager.getTaskForElement(element, true);
-					if (task != null) {
-						Calendar twoWeeks = TaskActivityUtil.getCalendar();
-						TaskActivityUtil.snapNextWorkWeek(twoWeeks);
-						twoWeeks.add(Calendar.DAY_OF_MONTH, 7);
-						setScheduledDate(task, twoWeeks, true);
-					}
-				}
-			}
-		};
-		action.setText(LABEL_TWO_WEEKS);
-		action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
-
-		if (singleTaskSelection != null && getScheduledForDate(singleTaskSelection) != null
-				&& isFloating(singleTaskSelection)) {
-
-			Calendar time = TaskActivityUtil.getCalendar();
-			time.setTime(getScheduledForDate(singleTaskSelection));
-
-			Calendar start = TaskActivityUtil.getCalendar();
-			start.setTime(TasksUiPlugin.getTaskActivityManager().getActivityFuture().getStart().getTime());
-
-			Calendar end = TaskActivityUtil.getCalendar();
-			end.setTime(TasksUiPlugin.getTaskActivityManager().getActivityFuture().getStart().getTime());
-			TaskActivityUtil.snapEndOfWeek(end);
-
-			if (TaskActivityUtil.isBetween(time, start, end)) {
-				action.setChecked(true);
-			}
-		}
-
+		// Next Week
+		action = createDateSelectionAction(TasksUiPlugin.getTaskActivityManager().getActivityNextWeek(), null);
 		subMenuManager.add(action);
 
+		// Future
 		if (singleTaskSelection != null && getScheduledForDate(singleTaskSelection) != null) {
 
 			Calendar time = TaskActivityUtil.getCalendar();
@@ -228,7 +99,7 @@ public class ScheduleTaskMenuContributor implements IDynamicSubMenuContributor {
 
 			Calendar start = TaskActivityUtil.getCalendar();
 			start.setTime(TasksUiPlugin.getTaskActivityManager().getActivityFuture().getStart().getTime());
-			start.add(Calendar.WEEK_OF_MONTH, 1);
+			//start.add(Calendar.WEEK_OF_MONTH, 1);
 
 			if (time.compareTo(start) >= 0) {
 				// future
@@ -246,11 +117,12 @@ public class ScheduleTaskMenuContributor implements IDynamicSubMenuContributor {
 
 		subMenuManager.add(new Separator());
 
+		// Date Selection Dialog
 		action = new Action() {
 			@Override
 			public void run() {
-				Calendar theCalendar = Calendar.getInstance();
-				if (singleTaskSelection != null && getScheduledForDate(singleTaskSelection) != null) {
+				Calendar theCalendar = TaskActivityUtil.getCalendar();
+				if (getScheduledForDate(singleTaskSelection) != null) {
 					theCalendar.setTime(getScheduledForDate(singleTaskSelection));
 				}
 				DateSelectionDialog reminderDialog = new DateSelectionDialog(PlatformUI.getWorkbench()
@@ -258,102 +130,108 @@ public class ScheduleTaskMenuContributor implements IDynamicSubMenuContributor {
 						.getShell(), theCalendar, DatePicker.TITLE_DIALOG, false);
 				int result = reminderDialog.open();
 				if (result == Window.OK) {
-					for (AbstractTaskContainer element : taskListElementsToSchedule) {
-						AbstractTask task = null;
-						if (element instanceof AbstractTask) {
-							task = (AbstractTask) element;
-							if (reminderDialog.getDate() != null) {
-								Calendar cal = TaskActivityUtil.getCalendar();
-								cal.setTime(reminderDialog.getDate());
-								setScheduledDate(task, cal, false);
-							} else {
-								setScheduledDate(task, null, false);
-							}
-						}
+					Calendar cal = null;
+					if (reminderDialog.getDate() != null) {
+						cal = TaskActivityUtil.getCalendar();
+						cal.setTime(reminderDialog.getDate());
 					}
+
+					ScheduledTaskContainer dummy = TasksUiPlugin.getTaskActivityManager().getActivityContainer(cal,
+							false);
+					if (dummy == null) {
+						dummy = new ScheduledTaskContainer(TasksUiPlugin.getTaskActivityManager(), cal, cal, "");
+					}
+
+					setScheduledDate(dummy);
 				}
 			}
 		};
 		action.setText(LABEL_CALENDAR);
 //		action.setImageDescriptor(TasksUiImages.CALENDAR);
 //		action.setImageDescriptor(TasksUiImages.SCHEDULE_DAY);
-		action.setEnabled(canSchedule(singleSelection, taskListElementsToSchedule));
+		action.setEnabled(canSchedule());
 		subMenuManager.add(action);
 
 		action = new Action() {
 			@Override
 			public void run() {
-				for (AbstractTaskContainer element : taskListElementsToSchedule) {
-					AbstractTask task = tasklistManager.getTaskForElement(element, true);
-					setScheduledDate(task, null, false);
-				}
+				setScheduledDate(null);
 			}
 		};
 		action.setText(LABEL_NOT_SCHEDULED);
 //		action.setImageDescriptor(TasksUiImages.REMOVE);
-		if (singleTaskSelection != null) {
-			if (getScheduledForDate(singleTaskSelection) == null) {
-				action.setChecked(true);
-			}
+		if (getScheduledForDate(singleTaskSelection) == null) {
+			action.setChecked(true);
 		}
 		subMenuManager.add(action);
 		return subMenuManager;
 	}
 
-	private void getDayLabel(int i, Action action) {
-		if (i > 8) {
-			// rotates up to 7 days ahead
-			i = i - 7;
-		}
-		switch (i) {
-		case Calendar.MONDAY:
-			action.setText("Monday");
-			break;
-		case Calendar.TUESDAY:
-			action.setText("Tuesday");
-			break;
-		case Calendar.WEDNESDAY:
-			action.setText("Wednesday");
-			break;
-		case Calendar.THURSDAY:
-			action.setText("Thursday");
-			break;
-		case Calendar.FRIDAY:
-			action.setText("Friday");
-			break;
-		case Calendar.SATURDAY:
-			action.setText("Saturday");
-			break;
-		case 8:
-			action.setText("Sunday");
-			break;
-		default:
-			break;
+	private Action createDateSelectionAction(final ScheduledTaskContainer dateContainer, ImageDescriptor imageDescriptor) {
+		Action action = new Action() {
+			@Override
+			public void run() {
+				setScheduledDate(dateContainer);
+			}
+		};
+		action.setText(dateContainer.getSummary());
+		action.setImageDescriptor(imageDescriptor);
+		action.setEnabled(canSchedule());
+
+		Date scheduledDate = getScheduledForDate(singleTaskSelection);
+		if (scheduledDate != null) {
+
+			Calendar cal = TaskActivityUtil.getCalendar();
+			cal.setTime(scheduledDate);
+
+			action.setChecked(isFloating(singleTaskSelection) == dateContainer.isCaptureFloating()
+					&& dateContainer.includes(cal));
 		}
+		return action;
 	}
 
-	private boolean canSchedule(AbstractTaskContainer singleSelection, List<AbstractTaskContainer> elements) {
-		if (singleSelection instanceof AbstractTask) {
-			return ((!((AbstractTask) singleSelection).isCompleted()) || elements.size() > 0);
-		} else {
-			return elements.size() > 0;
+	private boolean canSchedule() {
+		if (taskListElementsToSchedule.size() == 0) {
+			return true;
 		}
-		// return (singleSelection != null && !singleSelection.isCompleted())
-		// || elements.size() > 0;
+		return !(singleTaskSelection).isCompleted();
+//		if (taskListElementsToSchedule.size() == 0) {
+//			return true;
+//		} else if (singleTaskSelection instanceof AbstractTask) {
+//			return ((!(singleTaskSelection).isCompleted()) || taskListElementsToSchedule.size() > 0);
+//		} else {
+//			return taskListElementsToSchedule.size() > 0;
+//		}
 	}
 
-	protected void setScheduledDate(AbstractTask task, Calendar scheduledDate, boolean floating) {
-		if (task != null) {
-			if (scheduledDate != null) {
-				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, scheduledDate.getTime(), floating);
+//	protected void setScheduledDate(Calendar scheduledDate, boolean floating) {
+//		for (AbstractTaskContainer element : taskListElementsToSchedule) {
+//			AbstractTask task = getTaskForElement(element, true);
+//			if (scheduledDate != null) {
+//				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, scheduledDate.getTime(), floating);
+//			} else {
+//				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, null, floating);
+//			}
+//		}
+//	}
+
+	protected void setScheduledDate(ScheduledTaskContainer dateContainer) {
+		for (AbstractTaskContainer element : taskListElementsToSchedule) {
+			AbstractTask task = getTaskForElement(element, true);
+			if (dateContainer != null && dateContainer.getStart() != null) {
+				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, dateContainer.getStart().getTime(),
+						dateContainer.isCaptureFloating());
 			} else {
-				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, null, floating);
+				TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, null, false);
 			}
 		}
 	}
 
 	protected Date getScheduledForDate(final AbstractTask singleTaskSelection) {
-		return singleTaskSelection.getScheduledForDate();
+		if (singleTaskSelection != null) {
+			return singleTaskSelection.getScheduledForDate();
+		}
+		return null;
 	}
 
 	protected boolean isFloating(AbstractTask task) {
@@ -364,4 +242,13 @@ public class ScheduleTaskMenuContributor implements IDynamicSubMenuContributor {
 		Date date = getScheduledForDate(task);
 		return TasksUiPlugin.getTaskActivityManager().isPastReminder(date, task.isCompleted());
 	}
+
+	private AbstractTask getTaskForElement(AbstractTaskContainer element, boolean force) {
+		AbstractTask task = null;
+		if (element instanceof AbstractTask) {
+			task = (AbstractTask) element;
+		}
+		return task;
+	}
+
 }
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorInputFactory.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorInputFactory.java
index 9254e73f3..d265ce8b3 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorInputFactory.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorInputFactory.java
@@ -9,7 +9,10 @@
 package org.eclipse.mylyn.internal.tasks.ui.editors;
 
 import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
+import org.eclipse.mylyn.monitor.core.StatusHandler;
 import org.eclipse.mylyn.tasks.core.AbstractTask;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.ui.TasksUi;
@@ -32,7 +35,15 @@ public class TaskEditorInputFactory implements IElementFactory {
 		if (task != null) {
 			TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
 					task.getRepositoryUrl());
-			return new TaskEditorInput(taskRepository, task);
+			if (taskRepository != null) {
+				return new TaskEditorInput(taskRepository, task);
+			} else {
+				StatusHandler.log(new Status(IStatus.WARNING, TasksUiPlugin.ID_PLUGIN, "Repository for connector kind "
+						+ task.getConnectorKind() + " with url " + task.getRepositoryUrl() + " cannont be found."));
+			}
+		} else {
+			StatusHandler.log(new Status(IStatus.WARNING, TasksUiPlugin.ID_PLUGIN, "Task with handle \"" + handle
+					+ "\" could not be found in task list."));
 		}
 		return null;
 	}
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java
index 08308e92b..73a5a815b 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java
@@ -189,9 +189,10 @@ public class TaskPlanningEditor extends TaskFormPage {
 	public void updateTaskData(final AbstractTask updateTask) {
 		if (scheduleDatePicker != null && !scheduleDatePicker.isDisposed()) {
 			if (updateTask.getScheduledForDate() != null) {
-				scheduleDatePicker.setScheduledDate(updateTask.getScheduledForDate());
+				scheduleDatePicker.setScheduledDate(updateTask.getScheduledForDate(),
+						updateTask.internalIsFloatingScheduledDate());
 			} else {
-				scheduleDatePicker.setScheduledDate(null);
+				scheduleDatePicker.setScheduledDate(null, false);
 			}
 		}
 
@@ -669,7 +670,7 @@ public class TaskPlanningEditor extends TaskFormPage {
 
 			@Override
 			public void linkActivated(HyperlinkEvent e) {
-				scheduleDatePicker.setScheduledDate(null);
+				scheduleDatePicker.setScheduledDate(null, false);
 				task.setReminded(false);
 				TaskPlanningEditor.this.markDirty(true);
 			}
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/tasks/ui/editors/AbstractNewRepositoryTaskEditor.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/tasks/ui/editors/AbstractNewRepositoryTaskEditor.java
index 5928abfeb..bc57d9802 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/tasks/ui/editors/AbstractNewRepositoryTaskEditor.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/tasks/ui/editors/AbstractNewRepositoryTaskEditor.java
@@ -8,9 +8,9 @@
 package org.eclipse.mylyn.tasks.ui.editors;
 
 import java.util.ArrayList;
-import java.util.Calendar;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Date;
 import java.util.List;
 
 import org.eclipse.core.runtime.CoreException;
@@ -22,11 +22,10 @@ import org.eclipse.jface.layout.GridDataFactory;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.SelectionChangedEvent;
 import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
 import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
+import org.eclipse.mylyn.internal.tasks.ui.ScheduleDatePicker;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
-import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;
 import org.eclipse.mylyn.internal.tasks.ui.editors.RepositoryTaskOutlineNode;
 import org.eclipse.mylyn.internal.tasks.ui.editors.RepositoryTaskSelection;
 import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
@@ -34,7 +33,6 @@ import org.eclipse.mylyn.tasks.core.AbstractTask;
 import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
 import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
 import org.eclipse.mylyn.tasks.core.ITaskList;
-import org.eclipse.mylyn.tasks.ui.DatePicker;
 import org.eclipse.mylyn.tasks.ui.TasksUi;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CCombo;
@@ -84,7 +82,7 @@ public abstract class AbstractNewRepositoryTaskEditor extends AbstractRepository
 
 	private static final String ERROR_CREATING_BUG_REPORT = "Error creating bug report";
 
-	protected DatePicker scheduledForDate;
+	protected ScheduleDatePicker scheduledForDate;
 
 	protected Spinner estimatedTime;
 
@@ -210,22 +208,22 @@ public abstract class AbstractNewRepositoryTaskEditor extends AbstractRepository
 		GridData clientDataLayout = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
 		sectionClient.setLayoutData(clientDataLayout);
 
-		// Reminder
+		// Scheduled date
 		getManagedForm().getToolkit().createLabel(sectionClient, "Scheduled for:");
 		// label.setForeground(toolkit.getColors().getColor(FormColors.TITLE));
-		scheduledForDate = new DatePicker(sectionClient, SWT.FLAT, DatePicker.LABEL_CHOOSE);
+		scheduledForDate = new ScheduleDatePicker(sectionClient, null, SWT.FLAT);
 		scheduledForDate.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
 		scheduledForDate.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
-		Calendar newTaskSchedule = Calendar.getInstance();
-		int scheduledEndHour = TasksUiPlugin.getDefault().getPreferenceStore().getInt(
-				TasksUiPreferenceConstants.PLANNING_ENDHOUR);
+//		Calendar newTaskSchedule = TaskActivityUtil.getCalendar();
+//		int scheduledEndHour = TasksUiPlugin.getDefault().getPreferenceStore().getInt(
+//				TasksUiPreferenceConstants.PLANNING_ENDHOUR);
 		// If past scheduledEndHour set for following day
-		if (newTaskSchedule.get(Calendar.HOUR_OF_DAY) >= scheduledEndHour) {
-			TaskActivityUtil.snapForwardNumDays(newTaskSchedule, 1);
-		} else {
-			TaskActivityUtil.snapEndOfWorkDay(newTaskSchedule);
-		}
-		scheduledForDate.setDate(newTaskSchedule);
+//		if (newTaskSchedule.get(Calendar.HOUR_OF_DAY) >= scheduledEndHour) {
+//			TaskActivityUtil.snapForwardNumDays(newTaskSchedule, 1);
+//		} else {
+//			TaskActivityUtil.snapEndOfWorkDay(newTaskSchedule);
+//		}
+//		scheduledForDate.setDate(newTaskSchedule);
 //		Button removeReminder = getManagedForm().getToolkit().createButton(sectionClient, "Clear",
 //				SWT.PUSH | SWT.CENTER);
 //		removeReminder.addSelectionListener(new SelectionAdapter() {
@@ -241,7 +239,7 @@ public abstract class AbstractNewRepositoryTaskEditor extends AbstractRepository
 		clearReminder.addHyperlinkListener(new HyperlinkAdapter() {
 			@Override
 			public void linkActivated(HyperlinkEvent e) {
-				scheduledForDate.setDate(null);
+				scheduledForDate.setScheduledDate(null, false);
 			}
 		});
 
@@ -477,13 +475,12 @@ public abstract class AbstractNewRepositoryTaskEditor extends AbstractRepository
 		if (newTask != null) {
 			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
 				public void run() {
-					Calendar selectedDate = null;
+					Date selectedDate = null;
 					if (scheduledForDate != null) {
-						selectedDate = scheduledForDate.getDate();
+						selectedDate = scheduledForDate.getScheduledDate();
 					}
 					if (selectedDate != null) {
-						// NewLocalTaskAction.scheduleNewTask(newTask);
-						TasksUiPlugin.getTaskActivityManager().setScheduledFor(newTask, selectedDate.getTime());
+						TasksUiPlugin.getTaskActivityManager().setScheduledFor(newTask, selectedDate);
 					}
 
 					if (estimatedTime != null) {