| /******************************************************************************* |
| * Copyright (c) 2003, 2008 IBM Corporation 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: |
| * IBM Corporation - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.wst.server.ui.internal.wizard.fragment; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.wst.server.core.*; |
| import org.eclipse.wst.server.core.internal.*; |
| import org.eclipse.wst.server.core.model.PublishOperation; |
| import org.eclipse.wst.server.ui.internal.editor.IOrdered; |
| import org.eclipse.wst.server.ui.internal.wizard.WizardTaskUtil; |
| import org.eclipse.wst.server.ui.wizard.WizardFragment; |
| /** |
| * |
| */ |
| public class TasksWizardFragment extends WizardFragment { |
| private static final int TASKS_PER_PAGE = 5; |
| |
| public class TaskInfo implements IOrdered { |
| public int kind; |
| public String id; |
| public PublishOperation task2; |
| |
| private static final String DEFAULT = "default:"; |
| |
| public boolean isSelected() { |
| if (id == null) |
| return false; |
| |
| if (selectedTaskMap.containsKey(id)) |
| return (selectedTaskMap.get(id)).booleanValue(); |
| |
| if (selectedTaskMap.containsKey(DEFAULT + id)) |
| return (selectedTaskMap.get(DEFAULT + id)).booleanValue(); |
| |
| return false; |
| } |
| |
| public void setDefaultSelected(boolean sel) { |
| selectedTaskMap.put(DEFAULT + getId(), new Boolean(sel)); |
| } |
| |
| public boolean getDefaultSelected() { |
| return (selectedTaskMap.get(DEFAULT + id)).booleanValue(); |
| } |
| |
| public void setSelected(boolean sel) { |
| selectedTaskMap.put(getId(), new Boolean(sel)); |
| } |
| |
| public int getOrder() { |
| return task2.getOrder(); |
| } |
| |
| protected String getId() { |
| return id; |
| } |
| |
| public boolean equals(Object obj) { |
| if (!(obj instanceof TaskInfo)) |
| return false; |
| |
| TaskInfo ti = (TaskInfo) obj; |
| if (kind != ti.kind) |
| return false; |
| |
| if (id == null || !id.equals(ti.id)) |
| return false; |
| |
| if (task2 == null && ti.task2 != null) |
| return false; |
| |
| if (task2 != null && ti.task2 == null) |
| return false; |
| |
| try { |
| if (task2 != null && ti.task2 != null) { |
| if (task2.getKind() != ti.task2.getKind()) |
| return false; |
| if (task2.getOrder() != ti.task2.getOrder()) |
| return false; |
| if (!task2.getLabel().equals(ti.task2.getLabel())) |
| return false; |
| if (!task2.getDescription().equals(ti.task2.getDescription())) |
| return false; |
| } |
| } catch (Exception e) { |
| // ignore |
| } |
| return true; |
| } |
| } |
| |
| protected List<TaskInfo> tasks; |
| protected boolean hasOptionalTasks; |
| protected boolean hasPreferredTasks; |
| |
| protected Map<String, Boolean> selectedTaskMap = new HashMap<String, Boolean>(); |
| |
| public TasksWizardFragment() { |
| // do nothing |
| } |
| |
| protected void createChildFragments(List<WizardFragment> list) { |
| if (tasks == null || tasks.isEmpty()) |
| return; |
| |
| int size = tasks.size(); |
| int pages = (size - 1) / TASKS_PER_PAGE + 1; |
| for (int i = 0; i < pages; i++) { |
| SubTasksWizardFragment fragment = new SubTasksWizardFragment(); |
| List list2 = tasks.subList(TASKS_PER_PAGE * i, Math.min(size, TASKS_PER_PAGE * (i+1))); |
| fragment.updateTasks(list2); |
| list.add(fragment); |
| } |
| } |
| |
| public void enter() { |
| updateTasks(); |
| } |
| |
| public List getChildFragments() { |
| updateTasks(); |
| return super.getChildFragments(); |
| } |
| |
| public void setTaskModel(TaskModel taskModel) { |
| super.setTaskModel(taskModel); |
| updateTasks(); |
| } |
| |
| public void updateTasks() { |
| if (getTaskModel() == null) { |
| tasks = null; |
| return; |
| } |
| |
| IServerAttributes server = (IServerAttributes) getTaskModel().getObject(TaskModel.TASK_SERVER); |
| List modules = (List) getTaskModel().getObject(TaskModel.TASK_MODULES); |
| |
| if (server != null && modules == null) { |
| final List<IModule[]> moduleList = new ArrayList<IModule[]>(); |
| ((Server) server).visit(new IModuleVisitor() { |
| public boolean visit(IModule[] module2) { |
| moduleList.add(module2); |
| return true; |
| } |
| }, null); |
| |
| modules = moduleList; |
| } |
| |
| if (server != null && modules != null) { |
| hasOptionalTasks = false; |
| hasPreferredTasks = false; |
| List<TaskInfo> taskList = new ArrayList<TaskInfo>(5); |
| createTasks(taskList, server, modules); |
| |
| if (tasks == null || !tasks.equals(taskList)) { |
| tasks = taskList; |
| updateChildFragments(); |
| |
| boolean b = hasOptionalTasks || hasPreferredTasks; |
| getTaskModel().putObject(WizardTaskUtil.TASK_HAS_TASKS, new Boolean(b)); |
| } |
| } |
| } |
| |
| protected void createTasks(List<TaskInfo> taskList, IServerAttributes server, List modules) { |
| if (server == null) |
| return; |
| |
| List<String> enabledTasks = ((Server)server).getEnabledOptionalPublishOperationIds(); |
| List<String> disabledTasks = ((Server)server).getDisabledPreferredPublishOperationIds(); |
| PublishOperation[] tasks2 = ((Server)server).getAllTasks(modules); |
| for (int j = 0; j < tasks2.length; j++) { |
| int kind = tasks2[j].getKind(); |
| String id = ((Server)server).getPublishOperationId(tasks2[j]); |
| if (kind == PublishOperation.OPTIONAL || kind == PublishOperation.PREFERRED) |
| hasOptionalTasks = true; |
| if (kind == PublishOperation.PREFERRED) |
| hasPreferredTasks = true; |
| tasks2[j].setTaskModel(getTaskModel()); |
| |
| boolean selected = true; |
| if (kind == PublishOperation.OPTIONAL) { |
| if (!enabledTasks.contains(id)) |
| selected = false; |
| } else if (kind == PublishOperation.PREFERRED) { |
| if (disabledTasks.contains(id)) |
| selected = false; |
| } |
| taskList.add(getServerTask(server, tasks2[j], selected)); |
| } |
| } |
| |
| public TaskInfo getServerTask(IServerAttributes server, PublishOperation task2, boolean selected) { |
| TaskInfo sti = new TaskInfo(); |
| sti.task2 = task2; |
| sti.kind = task2.getKind(); |
| sti.id = ((Server)server).getPublishOperationId(task2); |
| sti.setDefaultSelected(selected); |
| |
| return sti; |
| } |
| |
| /** |
| * @see WizardFragment#performFinish(IProgressMonitor) |
| */ |
| public void performFinish(IProgressMonitor monitor) throws CoreException { |
| if (!hasOptionalTasks) |
| return; |
| |
| if (tasks == null || tasks.isEmpty()) |
| return; |
| |
| TaskModel taskModel = getTaskModel(); |
| IServer server = (IServer)taskModel.getObject(TaskModel.TASK_SERVER); |
| if (server == null) |
| return; |
| |
| boolean createdWC = false; |
| ServerWorkingCopy wc = null; |
| if (server instanceof ServerWorkingCopy) |
| wc = (ServerWorkingCopy)server; |
| else { |
| wc = (ServerWorkingCopy)server.createWorkingCopy(); |
| createdWC = true; |
| } |
| |
| // compare lists |
| List<String> disabled = new ArrayList<String>(); |
| List<String> enabled = new ArrayList<String>(); |
| Iterator iterator = tasks.iterator(); |
| while (iterator.hasNext()) { |
| TaskInfo task = (TaskInfo)iterator.next(); |
| if (PublishOperation.REQUIRED == task.kind) |
| continue; |
| |
| String id = wc.getPublishOperationId(task.task2); |
| if (PublishOperation.PREFERRED == task.kind) { |
| if (!task.isSelected()) |
| disabled.add(id); |
| } else if (PublishOperation.OPTIONAL == task.kind) { |
| if (task.isSelected()) |
| enabled.add(id); |
| } |
| } |
| |
| List<String> curDisabled = wc.getDisabledPreferredPublishOperationIds(); |
| List<String> curEnabled = wc.getEnabledOptionalPublishOperationIds(); |
| |
| boolean different = false; |
| if (curEnabled.size() != enabled.size() || curDisabled.size() != disabled.size()) { |
| different = true; |
| } else { |
| for (String id : curDisabled) { |
| if (!disabled.contains(id)) |
| different = true; |
| } |
| for (String id : curEnabled) { |
| if (!enabled.contains(id)) |
| different = true; |
| } |
| } |
| |
| if (different) { |
| wc.resetPreferredPublishOperations(); |
| wc.resetOptionalPublishOperations(); |
| |
| Iterator<TaskInfo> iterator2 = tasks.iterator(); |
| while (iterator2.hasNext()) { |
| TaskInfo task = iterator2.next(); |
| if (PublishOperation.REQUIRED == task.kind) |
| continue; |
| |
| if (PublishOperation.PREFERRED == task.kind) { |
| if (!task.isSelected()) |
| wc.disablePreferredPublishOperations(task.task2); |
| } else if (PublishOperation.OPTIONAL == task.kind) { |
| if (task.isSelected()) |
| wc.enableOptionalPublishOperations(task.task2); |
| } |
| } |
| } |
| |
| if (createdWC && wc.isDirty()) |
| wc.save(true, monitor); |
| monitor.done(); |
| } |
| } |