<page

        category="org.eclipse.wst.server.ui.preferencePage"

        class="org.eclipse.wst.server.ui.internal.WorkinprogressPage"

        id="org.eclipse.wst.server.ui.workinprogress.preferencePage"

        name="Work in progress">

  </page>

package org.eclipse.wst.server.ui.internal;

import org.eclipse.jface.preference.PreferencePage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.IWorkbenchPreferencePage;

import org.eclipse.wst.server.core.internal.ServerPreferences;

public class WorkinprogressPage extends PreferencePage implements IWorkbenchPreferencePage {

	protected ServerPreferences preferences;

	protected Button useWorkinprogressDeltaProcessing;

	public WorkinprogressPage() {

		super();

		preferences = ServerPreferences.getInstance();

	}

	protected Control createContents(Composite parent) {

		initializeDialogUnits(parent);

		Composite composite = new Composite(parent, SWT.NONE);

		GridLayout layout = new GridLayout();

		layout.horizontalSpacing = convertHorizontalDLUsToPixels(4);

		layout.verticalSpacing = convertVerticalDLUsToPixels(4);

		layout.marginWidth = 0;

		layout.marginHeight = 0;

		layout.numColumns = 3;

		composite.setLayout(layout);

		GridData data = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);

		composite.setLayoutData(data);

		useWorkinprogressDeltaProcessing = new Button(composite, SWT.CHECK);

		useWorkinprogressDeltaProcessing.setText("Use resource deltas to compute module publish state");

		data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);

		data.horizontalSpan = 3;

		useWorkinprogressDeltaProcessing.setLayoutData(data);

		useWorkinprogressDeltaProcessing.setSelection(preferences.isWorkinprogressDeltaProcessing());

		return null;

	}

	public void init(IWorkbench workbench) {

		// TODO Auto-generated method stub

	}

	public boolean performOk() {

		preferences.setWorkinprogressDeltaProcessing(useWorkinprogressDeltaProcessing.getSelection());

		return true;

	}

	protected void performDefaults() {

		useWorkinprogressDeltaProcessing.setSelection(preferences.isDefaultWorkinprogressDeltaProcessing());

	}

}

internal.default.compliance=default

import org.eclipse.core.resources.IResourceDelta;

	public abstract IModuleResourceDelta getModuleResourceDelta(IResourceDelta workspaceDelta) throws CoreException;

			if (ServerPreferences.getInstance().isWorkinprogressDeltaProcessing()) {

				// search for changes in deployed modules

				Map<IModule, Set<IServer>> modules = new HashMap<IModule, Set<IServer>>();

				for (IServer server : getServers()) {

					if (server.getAdapter(ServerDelegate.class) == null) continue; // server has not been published yet

					/*

					 * TODO server.getModules() returns root modules -- will this miss changes in child modules???

					 */

					for (IModule module : server.getModules()) {

						Set<IServer> servers = modules.get(module);

						if (servers == null) {

							servers = new HashSet<IServer>();

							modules.put(module, servers);

						}

						servers.add(server);

					}

				}

				for (IModule module : modules.keySet()) {

					ModuleDelegate delegate = (ModuleDelegate) module.getAdapter(ModuleDelegate.class);

					if (delegate == null) continue; // module has not been published yet

					try {

						/*

						 * The idea is to eventually use moduleDelta in background thread

						 * to actualy publish incremental changes. Otherwise, it is possible

						 * to implement much cheaper delegate.hasChanges(delta) which

						 * does not deeply traverse all changes.

						 */

						IModuleResourceDelta moduleDelta = delegate.getModuleResourceDelta(delta);

						if (IResourceDelta.NO_CHANGE != moduleDelta.getKind()) {

							for (IServer server : modules.get(module)) {

								((Server) server).handleModuleProjectChange(module);

							}

						}

					} catch (Exception e) {

						Trace.trace(Trace.SEVERE, "Error responding to resource change", e);

					}

				}

			}

	private static final String PREF_WORKINPROGRESS_DELTA_PROCESSING = "delta-processing";

	public boolean isWorkinprogressDeltaProcessing() {

		return preferences.getBoolean(PREF_WORKINPROGRESS_DELTA_PROCESSING);

	}

	public boolean isDefaultWorkinprogressDeltaProcessing() {

		return false;

	}

	public void setWorkinprogressDeltaProcessing(boolean workinprogress) {

		preferences.setValue(PREF_WORKINPROGRESS_DELTA_PROCESSING, workinprogress);

		ServerPlugin.getInstance().savePluginPreferences();

	}

package org.eclipse.wst.server.core.internal;

import java.io.File;

import java.util.List;

import org.eclipse.core.resources.IContainer;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IFolder;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.wst.common.componentcore.resources.VirtualTreeNode;

import org.eclipse.wst.common.componentcore.resources.VirtualTreeNode.Entry;

import org.eclipse.wst.server.core.model.IModuleFolder;

import org.eclipse.wst.server.core.model.IModuleResource;

/**

 * IModuleFolder implementation that populates members lazily, when requested.

 * #members() is not thread-safe.

 */

public class ModuleFolder2 implements IModuleFolder {

	private final VirtualTreeNode folder;

	private IModuleResource[] members;

	public ModuleFolder2(VirtualTreeNode folder) {

		this.folder = folder;

	}

	public IModuleResource[] members() {

		if (members == null) {

			try {

				List<VirtualTreeNode> children = folder.members();

				members = new IModuleResource[children.size()];

				int i = 0;

				for (VirtualTreeNode child : children) {

					members[i++] = newModuleResource(child);

				}

			} catch (CoreException e) {

				// TODO log

			}

		}

		return members;

	}

	public IPath getModuleRelativePath() {

		// TODO cache

		return folder.getRuntimePath().removeLastSegments(1).makeRelative();

	}

	public String getName() {

		// TODO cache

		return folder.getRuntimePath().lastSegment();

	}

	public Object getAdapter(Class adapter) {

		List<Entry> resolvedEntries = folder.getResolvedEntries();

		if (resolvedEntries == null || resolvedEntries.size() == 0) return null;

		if (IContainer.class.equals(adapter) || IFolder.class.equals(adapter)) {

			return resolvedEntries.get(0).getResource();

		}

		return null;

	}

	public static IModuleResource newModuleResource(VirtualTreeNode node) {

		IModuleResource result;

		if (node.isFolder()) {

			result = new ModuleFolder2(node);

		} else {

			IPath path = node.getRuntimePath().removeLastSegments(1).makeRelative();

			List<Entry> resolvedEntries = node.getResolvedEntries();

			IFile ifile = (IFile) resolvedEntries.get(0).getResource();

			if (ifile != null) {

				result = new ModuleFile(ifile, ifile.getName(), path);

			} else {

				File file = resolvedEntries.get(0).getFile();

				result = new ModuleFile(file, file.getName(), path);

			}

		}

		return result;

	}

}