RenJuan/TASKPM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ItEr19S08CUCreacionProxectoPlanificacionItEr18S08: Support for adding a Task at an arbitrary position.

Browse source 
It is necessary for splitting a task that is a child of a toptask.
This commit is contained in:
Óscar González Fernández 2009-07-28 20:17:49 +02:00 • committed by Javier Moran Rua
parent abcd9f15b2
commit 51da974113
12 changed files with 336 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/FunctionalityExposedForExtensions.java
View file

@ -15,6 +15,7 @@ import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.data.Dependency;
import org.zkoss.ganttz.data.GanttDiagramGraph;
import org.zkoss.ganttz.data.ITaskFundamentalProperties;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.data.TaskContainer;
import org.zkoss.ganttz.data.TaskLeaf;
@ -30,6 +31,8 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
private Map<Task, TaskContainer> fromTaskToParent = new HashMap<Task, TaskContainer>();
private List<Task> topLevel = new ArrayList<Task>();
@Override
public Task findAssociatedBean(T domainObject)
throws IllegalArgumentException {
@ -45,6 +48,8 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
fromTaskToDomain.put(task, domainObject);
if (parent != null) {
fromTaskToParent.put(task, parent);
} else {
topLevel.add(task);
}
}
@ -57,6 +62,7 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
parent.remove(toBeRemoved);
}
fromTaskToParent.remove(toBeRemoved);
topLevel.remove(toBeRemoved);
}
@Override
@ -69,6 +75,32 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
return fromTaskToDomain.get(task);
}
@Override
public Position findPositionFor(Task task) {
List<TaskContainer> ancestors = ancestorsOf(task);
if (ancestors.isEmpty()) {
return Position.createAtTopPosition(topLevel.indexOf(task));
}
TaskContainer parent = ancestors.get(0);
return Position.createPosition(ancestors, parent.getTasks()
.indexOf(task));
}
@Override
public Position findPositionFor(T domainObject) {
return findPositionFor(findAssociatedBean(domainObject));
}
private List<TaskContainer> ancestorsOf(Task task) {
ArrayList<TaskContainer> result = new ArrayList<TaskContainer>();
TaskContainer taskContainer = fromTaskToParent.get(task);
while (taskContainer != null) {
result.add(taskContainer);
taskContainer = fromTaskToParent.get(taskContainer);
}
return result;
}
}
private final Planner planner;
@ -106,25 +138,43 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
return result;
}
public void add(Collection<? extends T> domainObjects) {
public void add(Position position, Collection<? extends T> domainObjects) {
List<DomainDependency<T>> totalDependencies = new ArrayList<DomainDependency<T>>();
List<Task> tasksCreated = new ArrayList<Task>();
for (T object : domainObjects) {
Task task = extractTask(totalDependencies, object, null);
diagramGraph.addTopLevel(task);
this.planner.addTask(task);
tasksCreated.add(task);
}
if (position.isAppendToTop() || position.isAtTop()) {
this.diagramGraph.addTopLevel(tasksCreated);
} else {
this.diagramGraph.addTasks(tasksCreated);
TaskContainer parent = position.getParent();
parent.addAll(position.getInsertionPosition(), tasksCreated);
this.diagramGraph.childrenAddedTo(parent);
}
for (Dependency dependency : DomainDependency.toDependencies(mapper,
totalDependencies)) {
this.diagramGraph.add(dependency);
}
this.diagramGraph.enforceAllRestrictions();
this.planner.addTasks(position, tasksCreated);
}
public void add(Collection<? extends T> domainObjects) {
add(Position.createAppendToTopPosition(), domainObjects);
}
@Override
public void add(T domainObject) {
add(Position.createAppendToTopPosition(), domainObject);
}
@Override
public void add(Position position, T domainObject) {
LinkedList<T> list = new LinkedList<T>();
list.add(domainObject);
add(list);
add(position, list);
}
IDomainAndBeansMapper<T> getMapper() {
@ -137,12 +187,14 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
}
@Override
public void remove(T domainObject) {
public Position remove(T domainObject) {
Task task = mapper.findAssociatedBean(domainObject);
Position position = mapper.findPositionFor(task);
diagramGraph.remove(task);
task.removed();
planner.removeTask(task);
mapper.remove(domainObject);
return position;
}
@Override
@ -152,10 +204,8 @@ public class FunctionalityExposedForExtensions<T> implements IContext<T> {
@Override
public void replace(T oldDomainObject, T newDomainObject) {
remove(oldDomainObject);
add(newDomainObject);
// FIXME if oldDomainObject was a child from other it adds it to the top
// level
Position position = remove(oldDomainObject);
add(position, newDomainObject);
}
}

10
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/LeftPane.java
View file

@ -1,7 +1,9 @@
package org.zkoss.ganttz;
import java.util.Collection;
import java.util.List;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.HtmlMacroComponent;
@ -65,8 +67,12 @@ public class LeftPane extends HtmlMacroComponent {
leftTasksTree.taskRemoved(task);
}
public void addTask(Task newTask) {
leftTasksTree.addTask(newTask);
public void addTask(Position position, Task newTask) {
leftTasksTree.addTask(position, newTask);
}
public void addTasks(Position position, Collection<? extends Task> newTasks) {
leftTasksTree.addTasks(position, newTasks);
}
}

57
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/LeftTasksTree.java
View file

@ -4,6 +4,7 @@ import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
@ -15,6 +16,7 @@ import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.zkoss.ganttz.LeftTasksTreeRow.ILeftTasksTreeNavigator;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.data.TaskContainer;
import org.zkoss.ganttz.util.MutableTreeModel;
@ -233,7 +235,7 @@ public class LeftTasksTree extends HtmlMacroComponent {
if (!pendingToAddChildren.contains(parent))
return;
markLoaded(item);
fillModel(parent, parent.getTasks(), false);
fillModel(parent, 0, parent.getTasks(), false);
pendingToAddChildren.remove(parent);
}
@ -245,6 +247,7 @@ public class LeftTasksTree extends HtmlMacroComponent {
throw new RuntimeException(e);
}
}
private Method setLoadedMethod = null;
private Method getSetLoadedMethod() {
@ -277,26 +280,29 @@ public class LeftTasksTree extends HtmlMacroComponent {
this.tasks = tasks;
}
private void fillModel(List<Task> tasks, boolean firstTime) {
fillModel(this.tasksTreeModel.getRoot(), tasks, firstTime);
private void fillModel(Collection<? extends Task> tasks, boolean firstTime) {
fillModel(this.tasksTreeModel.getRoot(), 0, tasks, firstTime);
}
private void fillModel(Task parent, List<Task> children,
final boolean firstTime) {
for (Task node : children) {
if (firstTime) {
this.tasksTreeModel.add(parent, node);
private void fillModel(Task parent, Integer insertionPosition,
Collection<? extends Task> children, final boolean firstTime) {
if (firstTime) {
this.tasksTreeModel.add(parent, insertionPosition, children);
for (Task node : children) {
if (node.isContainer()) {
fillModel(node, node.getTasks(), firstTime);
fillModel(node, 0, node.getTasks(), firstTime);
}
} else {
}
} else {
for (Task node : children) {
if (node.isContainer()) {
this.deferredFiller.addParentOfPendingToAdd(node);
}
// the node must be added after, so the multistepTreeFiller is
// ready
this.tasksTreeModel.add(parent, node);
}
// the node must be added after, so the multistepTreeFiller is
// ready
this.tasksTreeModel.add(parent, insertionPosition, children);
}
}
@ -326,9 +332,28 @@ public class LeftTasksTree extends HtmlMacroComponent {
tasksTree.setTreeitemRenderer(new TaskBeanRenderer());
}
void addTask(Task task) {
fillModel(Arrays.asList(task), false);
detailsForBeans.requestFocusFor(task);
void addTask(Position position, Task task) {
if (position.isAppendToTop()) {
fillModel(Arrays.asList(task), false);
detailsForBeans.requestFocusFor(task);
} else {
List<Task> toAdd = Arrays.asList(task);
fillModel(position.getParent(), position.getInsertionPosition(),
toAdd, false);
}
}
public void addTasks(Position position, Collection<? extends Task> newTasks) {
if (position.isAppendToTop()) {
fillModel(newTasks, false);
} else if (position.isAtTop()) {
fillModel(tasksTreeModel.getRoot(),
position.getInsertionPosition(), newTasks, false);
} else {
fillModel(position.getParent(), position.getInsertionPosition(),
newTasks, false);
}
}
public CommandContextualized<?> getGoingDownInLastArrowCommand() {

12
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/Planner.java
View file

@ -1,6 +1,7 @@
package org.zkoss.ganttz;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
@ -12,6 +13,7 @@ import org.zkoss.ganttz.adapters.IDomainAndBeansMapper;
import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.data.Dependency;
import org.zkoss.ganttz.data.GanttDiagramGraph;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.extensions.ICommand;
import org.zkoss.ganttz.extensions.ICommandOnTask;
@ -105,14 +107,18 @@ public class Planner extends XulElement {
dependencyRemovedListener);
}
public void addTask(Task newTask) {
public void addTasks(Position position, Collection<? extends Task> newTasks) {
TaskList taskList = getTaskList();
if (taskList != null && leftPane != null) {
taskList.addTask(newTask);
leftPane.addTask(newTask);
taskList.addTasks(position, newTasks);
leftPane.addTasks(position, newTasks);
}
}
public void addTask(Position position, Task task) {
addTasks(position, Arrays.asList(task));
}
void addDependencies(Collection<? extends Dependency> dependencies) {
DependencyList dependencyList = getDependencyList();
if (dependencyList == null) {

75
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskContainerComponent.java
View file

@ -1,10 +1,13 @@
package org.zkoss.ganttz;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.lang.Validate;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.data.TaskContainer;
import org.zkoss.ganttz.data.TaskContainer.IExpandListener;
@ -17,7 +20,8 @@ import org.zkoss.zk.ui.ext.AfterCompose;
* Created at Jul 1, 2009
* @author Lorenzo Tilve Álvaro <ltilve@igalia.com>
*/
public class TaskContainerComponent extends TaskComponent implements AfterCompose {
public class TaskContainerComponent extends TaskComponent implements
AfterCompose {
public static TaskContainerComponent asTask(Task taskContainerBean,
TaskList taskList) {
@ -49,7 +53,8 @@ public class TaskContainerComponent extends TaskComponent implements AfterCompos
taskContainer.addExpandListener(expandListener);
this.taskList = taskList;
for (Task task : taskContainer.getTasks()) {
getCurrentComponents().add(TaskComponent.asTaskComponent(task, taskList));
getCurrentComponents().add(
TaskComponent.asTaskComponent(task, taskList));
}
}
@ -70,9 +75,34 @@ public class TaskContainerComponent extends TaskComponent implements AfterCompos
super.remove();
}
private void add(Integer insertionPosition,
Collection<? extends Task> newTasks) {
List<TaskComponent> taskComponents = new ArrayList<TaskComponent>();
for (Task task : newTasks) {
taskComponents.add(TaskComponent.asTaskComponent(task, taskList));
}
if (insertionPosition == null) {
subtaskComponents.addAll(taskComponents);
} else {
subtaskComponents.addAll(insertionPosition, taskComponents);
}
if (isExpanded()) {
TaskComponent previous = insertionPosition == 0 ? this
: subtaskComponents.get(insertionPosition - 1);
addAllAt(previous, taskComponents);
}
}
public void open() {
Component previous = this;
for (TaskComponent subtaskComponent : getCurrentComponents()) {
List<TaskComponent> toAdd = getCurrentComponents();
addAllAt(previous, toAdd);
}
private void addAllAt(Component previous, List<TaskComponent> toAdd) {
for (TaskComponent subtaskComponent : toAdd) {
taskList.addTaskComponent(previous, subtaskComponent, true);
previous = subtaskComponent;
}
@ -91,6 +121,17 @@ public class TaskContainerComponent extends TaskComponent implements AfterCompos
return subtaskComponents;
}
private static int find(List<TaskComponent> currentComponents, Task task) {
int i = 0;
for (TaskComponent t : currentComponents) {
if (t.getTask().equals(task)) {
return i;
}
i++;
}
return -1;
}
public boolean isExpanded() {
return getTaskContainer().isExpanded();
}
@ -101,12 +142,10 @@ public class TaskContainerComponent extends TaskComponent implements AfterCompos
@Override
protected String calculateClass() {
return super.calculateClass() +" "+ (getTaskContainer().isExpanded()?
"expanded":"closed");
return super.calculateClass() + " "
+ (getTaskContainer().isExpanded() ? "expanded" : "closed");
}
private void close() {
for (TaskComponent subtaskComponent : getCurrentComponents()) {
if (subtaskComponent instanceof TaskContainerComponent) {
@ -117,4 +156,26 @@ public class TaskContainerComponent extends TaskComponent implements AfterCompos
taskList.redrawDependencies();
}
}
public void insert(Position position, Collection<? extends Task> newTasks) {
if (position.getParent().equals(getTask())) {
add(position.getInsertionPosition(), newTasks);
} else {
Task mostRemoteAncestor = position.getMostRemoteAncestor();
Validate.isTrue(mostRemoteAncestor.equals(getTask()));
position = position.pop();
Task next = position.getMostRemoteAncestor();
List<TaskComponent> currentComponents = getCurrentComponents();
int find = find(currentComponents, next);
TaskComponent taskComponent = currentComponents.get(find);
if (taskComponent instanceof TaskContainerComponent) {
TaskContainerComponent container = (TaskContainerComponent) taskComponent;
container.insert(position, newTasks);
} else {
// TODO turn TaskComponent into container
}
}
}
}

107
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskList.java
View file

@ -15,6 +15,7 @@ import java.util.ListIterator;
import java.util.Map;
import org.zkoss.ganttz.data.Dependency;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.util.MenuBuilder;
import org.zkoss.ganttz.util.MenuBuilder.ItemAction;
@ -68,28 +69,31 @@ public class TaskList extends XulElement implements AfterCompose {
public List<DependencyComponent> asDependencyComponents(
Collection<? extends Dependency> dependencies) {
List<? extends Object> children = getChildren();
List<TaskComponent> taskComponents = Planner.findComponentsOfType(TaskComponent.class, children);
List<TaskComponent> taskComponents = Planner.findComponentsOfType(
TaskComponent.class, children);
Map<Task, TaskComponent> taskComponentByTask = new HashMap<Task, TaskComponent>();
for (TaskComponent taskComponent : taskComponents) {
taskComponent.publishTaskComponents(taskComponentByTask);
}
List<DependencyComponent> result = new ArrayList<DependencyComponent>();
for (Dependency dependency : dependencies) {
result.add(new DependencyComponent(taskComponentByTask.get(dependency
.getSource()), taskComponentByTask.get(dependency
.getDestination())));
result.add(new DependencyComponent(taskComponentByTask
.get(dependency.getSource()), taskComponentByTask
.get(dependency.getDestination())));
}
return result;
}
public void addTask(Task newTask) {
addTaskComponent(TaskComponent.asTaskComponent(newTask, this), true);
}
public synchronized void addTaskComponent(Component afterThis, final TaskComponent taskComponent,
boolean relocate) {
insertBefore(taskComponent, afterThis == null ? null : afterThis
.getNextSibling());
public synchronized void addTaskComponent(Component afterThis,
final TaskComponent taskComponent, boolean relocate) {
boolean isFirst = false;
if (afterThis == null) {
insertBefore(taskComponent, getFirstTaskComponent());
isFirst = true;
} else {
insertBefore(taskComponent, afterThis == null ? null : afterThis
.getNextSibling());
}
addContextMenu(taskComponent);
addListenerForTaskComponentEditForm(taskComponent);
ListIterator<WeakReference<DependencyAddedListener>> iterator = listeners
@ -104,7 +108,9 @@ public class TaskList extends XulElement implements AfterCompose {
}
taskComponent.afterCompose();
if (relocate) {
response(null, new AuInvoke(taskComponent, "relocateAfterAdding"));
response(null, new AuInvoke(taskComponent,
isFirst ? "relocateFirstAfterAdding"
: "relocateAfterAdding"));
setHeight(getHeight());// forcing smart update
adjustZoomColumnsHeight();
getGanttPanel().getDependencyList().redrawDependencies();
@ -118,10 +124,65 @@ public class TaskList extends XulElement implements AfterCompose {
}
public synchronized void addTaskComponent(final TaskComponent taskComponent, boolean relocate) {
addTaskComponent(null, taskComponent, relocate);
public synchronized void addTaskComponent(
final TaskComponent taskComponent, boolean relocate) {
addTaskComponent(getLastTaskComponent(), taskComponent, relocate);
}
private TaskComponent getLastTaskComponent() {
List<TaskComponent> taskComponents = getTaskComponents();
if (taskComponents.isEmpty())
return null;
return taskComponents.get(taskComponents.size() - 1);
}
private TaskComponent getFirstTaskComponent() {
List<TaskComponent> taskComponents = getTaskComponents();
if (taskComponents.isEmpty())
return null;
return taskComponents.get(0);
}
public void addTasks(Position position, Collection<? extends Task> newTasks) {
if (position.isAppendToTop()) {
for (Task t : newTasks) {
addTaskComponent(TaskComponent.asTaskComponent(t, this), true);
}
} else if (position.isAtTop()) {
int afterThisPosition = position.getInsertionPosition() - 1;
List<TaskComponent> taskComponents = getTaskComponents();
TaskComponent afterThis = afterThisPosition < 0 ? null
: afterThisPosition >= taskComponents.size() ? getLastTaskComponent()
: getTaskComponents().get(afterThisPosition);
for (Task t : newTasks) {
TaskComponent toAdd = TaskComponent.asTaskComponent(t, this);
addTaskComponent(afterThis, toAdd, true);
afterThis = toAdd;
}
} else {
Task mostRemoteAncestor = position.getMostRemoteAncestor();
TaskComponent taskComponent = find(mostRemoteAncestor);
if (taskComponent instanceof TaskContainerComponent) {
TaskContainerComponent container = (TaskContainerComponent) taskComponent;
container.insert(position, newTasks);
} else {
// TODO turn taskComponent into container
}
}
}
TaskComponent find(Task task) {
List<TaskComponent> taskComponents = getTaskComponents();
for (TaskComponent taskComponent : taskComponents) {
if (taskComponent.getTask().equals(task)) {
return taskComponent;
}
}
return null;
}
private void addListenerForTaskComponentEditForm(final TaskComponent taskComponent) {
if (editTaskCommand == null)
return;
@ -203,16 +264,16 @@ public class TaskList extends XulElement implements AfterCompose {
private Menupopup getContextMenuForTasks() {
if (contextMenu == null) {
MenuBuilder<TaskComponent> menuBuilder = MenuBuilder.on(getPage(), getTaskComponents());
menuBuilder.item(
"Add Dependency", new ItemAction<TaskComponent>() {
MenuBuilder<TaskComponent> menuBuilder = MenuBuilder.on(getPage(),
getTaskComponents());
menuBuilder.item("Add Dependency", new ItemAction<TaskComponent>() {
@Override
public void onEvent(TaskComponent choosen, Event event) {
choosen.addDependency();
}
@Override
public void onEvent(TaskComponent choosen, Event event) {
choosen.addDependency();
}
});
for (CommandOnTaskContextualized<?> command : commandsOnTasksContextualized) {
for (CommandOnTaskContextualized<?> command : commandsOnTasksContextualized) {
menuBuilder.item(command.getName(), command.toItemAction());
}
contextMenu = menuBuilder.createWithoutSettingContext();

15
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/adapters/IDomainAndBeansMapper.java
View file

@ -1,5 +1,6 @@
package org.zkoss.ganttz.adapters;
import org.zkoss.ganttz.data.Position;
import org.zkoss.ganttz.data.Task;
/**
@ -7,6 +8,20 @@ import org.zkoss.ganttz.data.Task;
*/
public interface IDomainAndBeansMapper<T> {
/**
* @param task
* @return the {@link Position} that specifies the path to reach the task
*/
Position findPositionFor(Task task);
/**
* @param domainObject
* @return the {@link Position} that specifies the path to reach the task
* associated to the domain object
* @see findPositionFor
*/
Position findPositionFor(T domainObject);
/**
* @param task
* @return the associated domain object

30
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/data/GanttDiagramGraph.java
View file

@ -3,6 +3,7 @@ package org.zkoss.ganttz.data;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
@ -45,11 +46,19 @@ public class GanttDiagramGraph {
private final TaskContainer container;
private final Map<Task, Object> alreadyRegistered = new WeakHashMap<Task, Object>();
private ParentShrinkingEnforcer(final TaskContainer container) {
if (container == null)
throw new IllegalArgumentException("container cannot be null");
this.container = container;
registerListeners();
}
void registerListeners() {
for (Task subtask : this.container.getTasks()) {
if (alreadyRegistered.containsKey(subtask))
continue;
subtask
.addFundamentalPropertiesChangeListener(new PropertyChangeListener() {
@ -120,7 +129,19 @@ public class GanttDiagramGraph {
addTask(task);
}
private void addTask(Task task) {
public void addTopLevel(Collection<? extends Task> tasks) {
for (Task task : tasks) {
addTopLevel(task);
}
}
public void addTasks(Collection<? extends Task> tasks) {
for (Task t : tasks) {
addTask(t);
}
}
public void addTask(Task task) {
graph.addVertex(task);
rulesEnforcersByTask.put(task, new DependencyRulesEnforcer(task));
if (task.isContainer()) {
@ -193,4 +214,11 @@ public class GanttDiagramGraph {
return Collections.unmodifiableList(topLevelTasks);
}
public void childrenAddedTo(TaskContainer task) {
ParentShrinkingEnforcer parentShrinkingEnforcer = parentShrinkingEnforcerByTask
.get(task);
parentShrinkingEnforcer.registerListeners();
parentShrinkingEnforcer.enforce();
}
}

4
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/data/TaskContainer.java
View file

@ -171,4 +171,8 @@ public class TaskContainer extends Task {
return tasks.contains(task);
}
public void addAll(int position, Collection<? extends Task> tasksCreated) {
tasks.addAll(position, tasksCreated);
}
}

9
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/extensions/ContextRelativeToOtherComponent.java
View file

@ -1,6 +1,7 @@
package org.zkoss.ganttz.extensions;
import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.data.Position;
import org.zkoss.zk.ui.Component;
/**
@ -40,10 +41,14 @@ public class ContextRelativeToOtherComponent<T> implements IContext<T> {
context.reload(configuration);
}
public void remove(T domainObject) {
context.remove(domainObject);
public Position remove(T domainObject) {
return context.remove(domainObject);
}
public void add(Position position, T domainObject) {
context.add(position, domainObject);
};
public void replace(T oldDomainObject, T newDomainObject) {
context.replace(oldDomainObject, newDomainObject);
};

11
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/extensions/ContextWithPlannerTask.java
View file

@ -2,6 +2,7 @@ package org.zkoss.ganttz.extensions;
import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.data.Position;
import org.zkoss.zk.ui.Component;
/**
@ -34,10 +35,14 @@ public class ContextWithPlannerTask<T> implements IContextWithPlannerTask<T> {
context.reload(configuration);
}
public void remove(T domainObject) {
context.remove(domainObject);
public Position remove(T domainObject) {
return context.remove(domainObject);
}
public void add(Position position, T domainObject) {
context.add(position, domainObject);
};
@Override
public Component getRelativeTo() {
return context.getRelativeTo();
@ -53,6 +58,4 @@ public class ContextWithPlannerTask<T> implements IContextWithPlannerTask<T> {
return task;
}
}

6
navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/extensions/IContext.java
View file

@ -7,6 +7,7 @@ import org.zkoss.ganttz.adapters.IStructureNavigator;
import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.data.Task;
import org.zkoss.zk.ui.Component;
import org.zkoss.ganttz.data.Position;
/**
* A facade for operations allowed to extensions <br />
@ -31,9 +32,10 @@ public interface IContext<T> {
/**
* Removing the tasks associated to the domainObject
* @param domainObject
* @return the Position in which the domainObject's task was
*/
void remove(T domainObject);
Position remove(T domainObject);
/**
* Retrieves the component associated to the action performed. Normally it
@ -46,4 +48,6 @@ public interface IContext<T> {
void replace(T oldDomainObject, T newDomainObject);
void add(Position position, T domainObject);
}