plugins/org.eclipse.wst.server.ui/serverui/org/eclipse/wst/server/ui/internal/view/servers/ServerTableViewer.java - servertools/webtools.servertools - Git at Google

 /*******************************************************************************
  * Copyright (c) 2003, 2011 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.view.servers;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jface.viewers.*;

 import org.eclipse.wst.server.core.*;
 import org.eclipse.wst.server.core.internal.Server;
 import org.eclipse.wst.server.core.util.PublishAdapter;
 import org.eclipse.wst.server.ui.internal.Trace;
 import org.eclipse.wst.server.ui.internal.viewers.BaseContentProvider;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.events.DisposeEvent;
 import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.graphics.Font;
 import org.eclipse.swt.graphics.FontData;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Item;
 import org.eclipse.swt.widgets.Tree;
 import org.eclipse.swt.widgets.TreeColumn;
 import org.eclipse.swt.widgets.TreeItem;
 import org.eclipse.swt.widgets.Widget;
 import org.eclipse.ui.PlatformUI;
 /**
  * Tree view showing servers and their associations.
  */
 public class ServerTableViewer extends TreeViewer {
 	protected static final String ROOT = "root";
 	protected static Color color;
 	protected static Font font;
 	protected Clipboard clipboard;

 	protected IServerLifecycleListener serverResourceListener;
 	protected IPublishListener publishListener;
 	protected IServerListener serverListener;

 	protected static Object deletedElement = null;

 	// servers that are currently publishing and starting
 	protected static Set<String> publishing = new HashSet<String>(4);
 	protected static Set<String> starting = new HashSet<String>(4);

 	protected ServerTableLabelProvider labelProvider;
 	//protected ISelectionListener dsListener;

 	protected ServersView view;

 	protected boolean animationActive = false;
 	protected boolean stopAnimation = false;

 	public class ServerContentProvider extends BaseContentProvider implements ITreeContentProvider {
 		public Object[] getElements(Object element) {
 			List<IServer> list = new ArrayList<IServer>();
 			IServer[] servers = ServerCore.getServers();
 			if (servers != null) {
 				int size = servers.length;
 				for (int i = 0; i < size; i++) {
 					if (!((Server)servers[i]).isPrivate())
 						list.add(servers[i]);
 				}
 			}
 			return list.toArray();
 		}

 		public Object[] getChildren(Object element) {
 			if (element instanceof ModuleServer) {
 				ModuleServer ms = (ModuleServer) element;
 				try {
 					IModule[] children = ms.server.getChildModules(ms.module, null);
 					int size = children.length;
 					ModuleServer[] ms2 = new ModuleServer[size];
 					for (int i = 0; i < size; i++) {
 						int size2 = ms.module.length;
 						IModule[] module = new IModule[size2 + 1];
 						System.arraycopy(ms.module, 0, module, 0, size2);
 						module[size2] = children[i];
 						ms2[i] = new ModuleServer(ms.server, module);
 					}
 					return ms2;
 				} catch (Exception e) {
 					return null;
 				}
 			}

 			IServer server = (IServer) element;
 			IModule[] modules = server.getModules();
 			int size = modules.length;
 			ModuleServer[] ms = new ModuleServer[size];
 			for (int i = 0; i < size; i++) {
 				ms[i] = new ModuleServer(server, new IModule[] { modules[i] });
 			}
 			return ms;
 		}

 		public Object getParent(Object element) {
 			if (element instanceof ModuleServer) {
 				ModuleServer ms = (ModuleServer) element;
 				return ms.server;
 			}
 			return null;
 		}

 		public boolean hasChildren(Object element) {
 			if (element instanceof ModuleServer) {
 				// Check if the module server has child modules.
 				ModuleServer curModuleServer = (ModuleServer)element;
 				IServer curServer = curModuleServer.server;
 				IModule[] curModule = curModuleServer.module;
 				if (curServer != null &&  curModule != null) {
 					IModule[] curChildModule = curServer.getChildModules(curModule, null);
 					if (curChildModule != null && curChildModule.length > 0)
 						return true;

 					return false;
 				}

 				return false;
 			}

 			IServer server = (IServer) element;
 			return server.getModules().length > 0;
 		}
 	}

 	protected void startThread() {
 		if (animationActive)
 			return;

 		stopAnimation = false;

 		final Display display = getTree().getDisplay();
 		final int SLEEP = 200;
 		final Runnable[] animator = new Runnable[1];
 		animator[0] = new Runnable() {
 			public void run() {
 				if (!stopAnimation) {
 					try {
 						labelProvider.animate();

 						int size = 0;
 						String[] servers;
 						synchronized (starting) {
 							size = starting.size();
 							servers = new String[size];
 							starting.toArray(servers);
 						}

 						for (int i = 0; i < size; i++) {
 							IServer server = ServerCore.findServer(servers[i]);
 							if (server != null && getTree() != null && !getTree().isDisposed())
 								updateAnimation(server);
 						}
 					} catch (Exception e) {
 						if (Trace.FINEST) {
 							Trace.trace(Trace.STRING_FINEST, "Error in Servers view animation", e);
 						}
 					}
 					display.timerExec(SLEEP, animator[0]);
 				}
 			}
 		};
 		Display.getDefault().asyncExec(new Runnable() {
 			public void run() {
 				display.timerExec(SLEEP, animator[0]);
 			}
 		});
 	}

 	protected void stopThread() {
 		stopAnimation = true;
 	}

 	/**
 	 * ServerTableViewer constructor comment.
 	 *
 	 * @param view the view
 	 * @param tree the tree
 	 */
 	public ServerTableViewer(final ServersView view, final Tree tree) {
 		super(tree);
 		this.view = view;
 		clipboard = new Clipboard(tree.getDisplay());
 	}

 	protected void initialize() {
 		ColumnViewerToolTipSupport.enableFor(this);
 		setContentProvider(new ServerContentProvider());
 		labelProvider = new ServerTableLabelProvider();
 		setLabelProvider(labelProvider);

 		setComparator(new ServerViewerComparator(labelProvider));

 		setInput(ROOT);
 		addListeners();

 		/*dsListener = new ISelectionListener() {
 			public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 				if (!(selection instanceof IStructuredSelection))
 					return;
 				IStructuredSelection sel = (IStructuredSelection) selection;
 				final Object obj = sel.getFirstElement();
 				IProject proj = null;
 				if (obj instanceof IResource) {
 					IResource res = (IResource) obj;
 					proj = res.getProject();
 				}
 				if (proj == null && obj != null) {
 					try {
 						IResource res = (IResource) Platform.getAdapterManager().getAdapter(obj, IResource.class);
 						if (res != null)
 							proj = res.getProject();
 					} catch (Exception e) {
 						// ignore
 					}
 				}
 				if (proj != null) {
 					final IProject project = proj;
 					final IModule module = ServerUtil.getModule(project);
 					Display.getDefault().asyncExec(new Runnable() {
 						public void run() {
 							if (getTree() == null || getTree().isDisposed())
 								return;

 							IServer defaultServer = null;
 							if (module != null)
 								defaultServer = ServerCore.getDefaultServer(module);

 							IServer oldDefaultServer = labelProvider.getDefaultServer();
 							if ((oldDefaultServer == null && defaultServer == null)
 									|| (oldDefaultServer != null && oldDefaultServer.equals(defaultServer)))
 								return;
 							labelProvider.setDefaultServer(defaultServer);

 							if (oldDefaultServer != null)
 								refresh(oldDefaultServer);
 							if (defaultServer != null)
 								refresh(defaultServer);
 						}
 					});
 				}
 			}
 		};
 		view.getViewSite().getPage().addSelectionListener(dsListener);*/

 		if (color == null) {
 			Display display = getControl().getDisplay();
 			color = display.getSystemColor(SWT.COLOR_DARK_GRAY);
 			FontData[] fd = getControl().getFont().getFontData();
 			int size = fd.length;
 			for (int i = 0; i < size; i++)
 				fd[i].setStyle(SWT.ITALIC);
 			font = new Font(display, fd);
 		}
 	}

 	protected void handleLabelProviderChanged(LabelProviderChangedEvent event) {
 		Object[] obj = event.getElements();
 		if (obj == null)
 			refresh(true);
 		else {
 			obj = adaptLabelChangeObjects(obj);
 			int size = obj.length;
 			for (int i = 0; i < size; i++)
 				update(obj[i], null);
 		}
 	}

 	/**
 	 * Resort the table based on field.
 	 *
 	 * @param column the column being updated
 	 * @param col
 	 */
 	protected void resortTable(final TreeColumn column, int col) {
 		ServerViewerComparator sorter = (ServerViewerComparator) getComparator();

 		if (col == sorter.getTopPriority())
 			sorter.reverseTopPriority();
 		else
 			sorter.setTopPriority(col);

 		PlatformUI.getWorkbench().getDisplay().asyncExec(
 			new Runnable() {
 				public void run() {
 					refresh();
 					updateDirectionIndicator(column);
 				}
 			});
 	}

 	/**
 	 * Update the direction indicator as column is now the primary column.
 	 *
 	 * @param column
 	 */
 	protected void updateDirectionIndicator(TreeColumn column) {
 		getTree().setSortColumn(column);
 		if (((ServerViewerComparator) getComparator()).getTopPriorityDirection() == ServerViewerComparator.ASCENDING)
 			getTree().setSortDirection(SWT.UP);
 		else
 			getTree().setSortDirection(SWT.DOWN);
 	}

 	protected Object[] adaptLabelChangeObjects(Object[] obj) {
 		if (obj == null)
 			return obj;

 		List<Object> list = new ArrayList<Object>();
 		int size = obj.length;
 		for (int i = 0; i < size; i++) {
 			if (obj[i] instanceof IModule) {
 				list.add(obj[i]);
 			} else if (obj[i] instanceof IServer) {
 				list.add(obj[i]);
 			} else if (obj[i] instanceof ModuleServer) {
 				list.add(obj[i]);
 			} else if (obj[i] instanceof IProject) {
 				IProject proj = (IProject) obj[i];

 				List<Object> list2 = new ArrayList<Object>();
 				getTreeChildren(list2, view.treeTable);

 				Iterator iterator = list2.iterator();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (o instanceof ModuleServer) {
 						ModuleServer ms = (ModuleServer) o;
 						if (proj.equals(ms.module[ms.module.length - 1].getProject()))
 							list.add(ms);
 					}
 				}
 			}
 		}

 		Object[] o = new Object[list.size()];
 		list.toArray(o);
 		return o;
 	}

 	private void getTreeChildren(List<Object> list, Widget widget) {
 		Item[] items = getChildren(widget);
 		for (int i = 0; i < items.length; i++) {
 			Item item = items[i];
 			Object data = item.getData();
 			if (data != null)
 				list.add(data);

 			if (getExpanded(item)) {
 				// only recurse if it is expanded - if
 				// not then the children aren't visible
 				getTreeChildren(list, item);
 			}
 		}
 	}

 	protected void addListeners() {
 		serverResourceListener = new IServerLifecycleListener() {
 			public void serverAdded(IServer server) {
 				addServer(server);
 				server.addServerListener(serverListener);
 				((Server) server).addPublishListener(publishListener);
 			}
 			public void serverChanged(IServer server) {
 				refreshServer(server);
 			}
 			public void serverRemoved(IServer server) {
 				removeServer(server);
 				server.removeServerListener(serverListener);
 				((Server) server).removePublishListener(publishListener);
 			}
 		};
 		ServerCore.addServerLifecycleListener(serverResourceListener);

 		publishListener = new PublishAdapter() {
 			public void publishStarted(IServer server) {
 				handlePublishChange(server, true);
 			}

 			public void publishFinished(IServer server, IStatus status) {
 				handlePublishChange(server, false);
 			}
 		};

 		serverListener = new IServerListener() {
 			public void serverChanged(ServerEvent event) {
 				if (event == null)
 					return;

 				int eventKind = event.getKind();
 				IServer server = event.getServer();
 				if ((eventKind & ServerEvent.SERVER_CHANGE) != 0) {
 					// server change event
 					if ((eventKind & ServerEvent.STATE_CHANGE) != 0) {
 						refreshServer(server);
 						int state = event.getState();
 						String id = server.getId();
 						if (state == IServer.STATE_STARTING || state == IServer.STATE_STOPPING) {
 							boolean startThread = false;
 							synchronized (starting) {
 								if (!starting.contains(id)) {
 									if (starting.isEmpty())
 										startThread = true;
 									starting.add(id);
 								}
 							}
 							if (startThread)
 								startThread();
 						} else {
 							boolean stopThread = false;
 							synchronized (starting) {
 								if (starting.contains(id)) {
 									starting.remove(id);
 									if (starting.isEmpty())
 										stopThread = true;
 								}
 							}
 							if (stopThread)
 								stopThread();
 						}
 					} else
 						refreshServer(server);
 				} else if ((eventKind & ServerEvent.MODULE_CHANGE) != 0) {
 					// module change event
 					if ((eventKind & ServerEvent.STATE_CHANGE) != 0 || (eventKind & ServerEvent.PUBLISH_STATE_CHANGE) != 0) {
 						refreshServer(server);
 					}
 				}
 			}
 		};

 		// add listeners to servers
 		IServer[] servers = ServerCore.getServers();
 		if (servers != null) {
 			int size = servers.length;
 			for (int i = 0; i < size; i++) {
 				servers[i].addServerListener(serverListener);
 				((Server) servers[i]).addPublishListener(publishListener);
 			}
 		}
 	}

 	/**
 	 * @param server
 	 * @deprecated With the introduction of the CNF this method shouldn't be called
 	 */
 	protected void refreshServer(final IServer server) {
 		Display.getDefault().asyncExec(new Runnable() {
 			public void run() {
 				try {
 					refresh(server);
 					ISelection sel = ServerTableViewer.this.getSelection();
 					ServerTableViewer.this.setSelection(sel);
 				} catch (Exception e) {
 					// ignore
 				}
 			}
 		});
 	}

 	protected void handleDispose(DisposeEvent event) {
 		stopThread();
 		//if (dsListener != null)
 		//	view.getViewSite().getPage().removeSelectionListener(dsListener);

 		ServerCore.removeServerLifecycleListener(serverResourceListener);

 		// remove listeners from server
 		IServer[] servers = ServerCore.getServers();
 		if (servers != null) {
 			int size = servers.length;
 			for (int i = 0; i < size; i++) {
 				if (serverListener != null)
 					servers[i].removeServerListener(serverListener);
 				if (publishListener != null)
 					((Server) servers[i]).removePublishListener(publishListener);
 			}
 		}

 		clipboard.dispose();

 		super.handleDispose(event);
 	}

 	/**
 	 * Called when the publish state changes.
 	 * @param server org.eclipse.wst.server.core.IServer
 	 */
 	protected void handlePublishChange(IServer server, boolean isPublishing) {
 		String serverId = server.getId();
 		if (isPublishing)
 			publishing.add(serverId);
 		else
 			publishing.remove(serverId);

 		refreshServer(server);
 	}

 	/**
 	 *
 	 */
 	protected void handleServerModulesChanged(IServer server2) {
 		if (server2 == null)
 			return;

 		IServer[] servers = ServerCore.getServers();
 		if (servers != null) {
 			int size = servers.length;
 			for (int i = 0; i < size; i++) {
 				if (server2.equals(servers[i]))
 					refresh(servers[i]);
 			}
 		}
 	}

 	/**
 	 * Called when an element is added.
 	 * @param server org.eclipse.wst.server.core.IServer
 	 */
 	protected void handleServerResourceAdded(IServer server) {
 		add(null, server);
 	}

 	/*protected void handleServerResourceAdded(IServerConfiguration configuration) {
 		configurationChange(configuration, true);
 	}*/

 	/**
 	 * Called when an element is changed.
 	 * @param server org.eclipse.wst.server.core.IServer
 	 */
 	protected void handleServerResourceChanged(IServer server) {
 		refresh(server);
 	}

 	/*protected void handleServerResourceChanged(IServerConfiguration configuration) {
 		IServer[] servers = ServerCore.getServers();
 		if (servers != null) {
 			int size = servers.length;
 			for (int i = 0; i < size; i++) {
 				IServerConfiguration config = servers[i].getServerConfiguration();
 				if (configuration.equals(config))
 					refresh(servers[i]);
 			}
 		}
 	}*/

 	/**
 	 * Called when an element is removed.
 	 * @param server org.eclipse.wst.server.core.IServer
 	 */
 	protected void handleServerResourceRemoved(IServer server) {
 		remove(server);

 		String serverId = server.getId();
 		publishing.remove(serverId);

 		view.getViewSite().getActionBars().getStatusLineManager().setMessage(null, null);
 	}

 	/*protected void handleServerResourceRemoved(IServerConfiguration configuration) {
 		configurationChange(configuration, false);
 	}*/

 	protected void addServer(final IServer server) {
 		Display.getDefault().asyncExec(new Runnable() {
 			public void run() {
 				add(ROOT, server);
 			}
 		});
 	}

 	protected void removeServer(final IServer server) {
 		Display.getDefault().asyncExec(new Runnable() {
 			public void run() {
 				remove(server);
 			}
 		});
 	}

 	public void doUpdateItem(Widget widget, Object element, boolean fullMap) {
 		if (widget instanceof TreeItem && color != null) {
 			TreeItem item = (TreeItem) widget;
 			if (element instanceof ModuleServer) {
 				ModuleServer ms = (ModuleServer) element;
 				IModule m = ms.module[ms.module.length-1];
 				if (m.isExternal())
 					item.setForeground(color);
 				else
 					item.setForeground(null);
 				if (ms.server.getModulePublishState(ms.module) != IServer.PUBLISH_STATE_NONE)
 					item.setFont(0, font);
 				else
 					item.setFont(0, null);
 			}
 		}
 		super.doUpdateItem(widget, element, fullMap);
 	}

 	protected void updateAnimation(IServer server) {
 		try {
 			Widget widget = doFindItem(server);
 			TreeItem item = (TreeItem) widget;
 			item.setText(1, labelProvider.getColumnText(server, 1));
 			item.setImage(1, labelProvider.getColumnImage(server, 1));
 		} catch (Exception e) {
 			if (Trace.WARNING) {
 				Trace.trace(Trace.STRING_WARNING, "Error in optimized animation", e);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2003, 2011 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.view.servers;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.jface.viewers.*;

	import org.eclipse.wst.server.core.*;
	import org.eclipse.wst.server.core.internal.Server;
	import org.eclipse.wst.server.core.util.PublishAdapter;
	import org.eclipse.wst.server.ui.internal.Trace;
	import org.eclipse.wst.server.ui.internal.viewers.BaseContentProvider;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.dnd.Clipboard;
	import org.eclipse.swt.events.DisposeEvent;
	import org.eclipse.swt.graphics.Color;
	import org.eclipse.swt.graphics.Font;
	import org.eclipse.swt.graphics.FontData;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Item;
	import org.eclipse.swt.widgets.Tree;
	import org.eclipse.swt.widgets.TreeColumn;
	import org.eclipse.swt.widgets.TreeItem;
	import org.eclipse.swt.widgets.Widget;
	import org.eclipse.ui.PlatformUI;
	/**
	* Tree view showing servers and their associations.
	*/
	public class ServerTableViewer extends TreeViewer {
	protected static final String ROOT = "root";
	protected static Color color;
	protected static Font font;
	protected Clipboard clipboard;

	protected IServerLifecycleListener serverResourceListener;
	protected IPublishListener publishListener;
	protected IServerListener serverListener;

	protected static Object deletedElement = null;

	// servers that are currently publishing and starting
	protected static Set<String> publishing = new HashSet<String>(4);
	protected static Set<String> starting = new HashSet<String>(4);

	protected ServerTableLabelProvider labelProvider;
	//protected ISelectionListener dsListener;

	protected ServersView view;

	protected boolean animationActive = false;
	protected boolean stopAnimation = false;

	public class ServerContentProvider extends BaseContentProvider implements ITreeContentProvider {
	public Object[] getElements(Object element) {
	List<IServer> list = new ArrayList<IServer>();
	IServer[] servers = ServerCore.getServers();
	if (servers != null) {
	int size = servers.length;
	for (int i = 0; i < size; i++) {
	if (!((Server)servers[i]).isPrivate())
	list.add(servers[i]);
	}
	}
	return list.toArray();
	}

	public Object[] getChildren(Object element) {
	if (element instanceof ModuleServer) {
	ModuleServer ms = (ModuleServer) element;
	try {
	IModule[] children = ms.server.getChildModules(ms.module, null);
	int size = children.length;
	ModuleServer[] ms2 = new ModuleServer[size];
	for (int i = 0; i < size; i++) {
	int size2 = ms.module.length;
	IModule[] module = new IModule[size2 + 1];
	System.arraycopy(ms.module, 0, module, 0, size2);
	module[size2] = children[i];
	ms2[i] = new ModuleServer(ms.server, module);
	}
	return ms2;
	} catch (Exception e) {
	return null;
	}
	}

	IServer server = (IServer) element;
	IModule[] modules = server.getModules();
	int size = modules.length;
	ModuleServer[] ms = new ModuleServer[size];
	for (int i = 0; i < size; i++) {
	ms[i] = new ModuleServer(server, new IModule[] { modules[i] });
	}
	return ms;
	}

	public Object getParent(Object element) {
	if (element instanceof ModuleServer) {
	ModuleServer ms = (ModuleServer) element;
	return ms.server;
	}
	return null;
	}

	public boolean hasChildren(Object element) {
	if (element instanceof ModuleServer) {
	// Check if the module server has child modules.
	ModuleServer curModuleServer = (ModuleServer)element;
	IServer curServer = curModuleServer.server;
	IModule[] curModule = curModuleServer.module;
	if (curServer != null && curModule != null) {
	IModule[] curChildModule = curServer.getChildModules(curModule, null);
	if (curChildModule != null && curChildModule.length > 0)
	return true;

	return false;
	}

	return false;
	}

	IServer server = (IServer) element;
	return server.getModules().length > 0;
	}
	}

	protected void startThread() {
	if (animationActive)
	return;

	stopAnimation = false;

	final Display display = getTree().getDisplay();
	final int SLEEP = 200;
	final Runnable[] animator = new Runnable[1];
	animator[0] = new Runnable() {
	public void run() {
	if (!stopAnimation) {
	try {
	labelProvider.animate();

	int size = 0;
	String[] servers;
	synchronized (starting) {
	size = starting.size();
	servers = new String[size];
	starting.toArray(servers);
	}

	for (int i = 0; i < size; i++) {
	IServer server = ServerCore.findServer(servers[i]);
	if (server != null && getTree() != null && !getTree().isDisposed())
	updateAnimation(server);
	}
	} catch (Exception e) {
	if (Trace.FINEST) {
	Trace.trace(Trace.STRING_FINEST, "Error in Servers view animation", e);
	}
	}
	display.timerExec(SLEEP, animator[0]);
	}
	}
	};
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	display.timerExec(SLEEP, animator[0]);
	}
	});
	}

	protected void stopThread() {
	stopAnimation = true;
	}

	/**
	* ServerTableViewer constructor comment.
	*
	* @param view the view
	* @param tree the tree
	*/
	public ServerTableViewer(final ServersView view, final Tree tree) {
	super(tree);
	this.view = view;
	clipboard = new Clipboard(tree.getDisplay());
	}

	protected void initialize() {
	ColumnViewerToolTipSupport.enableFor(this);
	setContentProvider(new ServerContentProvider());
	labelProvider = new ServerTableLabelProvider();
	setLabelProvider(labelProvider);

	setComparator(new ServerViewerComparator(labelProvider));

	setInput(ROOT);
	addListeners();

	/*dsListener = new ISelectionListener() {
	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
	if (!(selection instanceof IStructuredSelection))
	return;
	IStructuredSelection sel = (IStructuredSelection) selection;
	final Object obj = sel.getFirstElement();
	IProject proj = null;
	if (obj instanceof IResource) {
	IResource res = (IResource) obj;
	proj = res.getProject();
	}
	if (proj == null && obj != null) {
	try {
	IResource res = (IResource) Platform.getAdapterManager().getAdapter(obj, IResource.class);
	if (res != null)
	proj = res.getProject();
	} catch (Exception e) {
	// ignore
	}
	}
	if (proj != null) {
	final IProject project = proj;
	final IModule module = ServerUtil.getModule(project);
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	if (getTree() == null \|\| getTree().isDisposed())
	return;

	IServer defaultServer = null;
	if (module != null)
	defaultServer = ServerCore.getDefaultServer(module);

	IServer oldDefaultServer = labelProvider.getDefaultServer();
	if ((oldDefaultServer == null && defaultServer == null)
	\|\| (oldDefaultServer != null && oldDefaultServer.equals(defaultServer)))
	return;
	labelProvider.setDefaultServer(defaultServer);

	if (oldDefaultServer != null)
	refresh(oldDefaultServer);
	if (defaultServer != null)
	refresh(defaultServer);
	}
	});
	}
	}
	};
	view.getViewSite().getPage().addSelectionListener(dsListener);*/

	if (color == null) {
	Display display = getControl().getDisplay();
	color = display.getSystemColor(SWT.COLOR_DARK_GRAY);
	FontData[] fd = getControl().getFont().getFontData();
	int size = fd.length;
	for (int i = 0; i < size; i++)
	fd[i].setStyle(SWT.ITALIC);
	font = new Font(display, fd);
	}
	}

	protected void handleLabelProviderChanged(LabelProviderChangedEvent event) {
	Object[] obj = event.getElements();
	if (obj == null)
	refresh(true);
	else {
	obj = adaptLabelChangeObjects(obj);
	int size = obj.length;
	for (int i = 0; i < size; i++)
	update(obj[i], null);
	}
	}

	/**
	* Resort the table based on field.
	*
	* @param column the column being updated
	* @param col
	*/
	protected void resortTable(final TreeColumn column, int col) {
	ServerViewerComparator sorter = (ServerViewerComparator) getComparator();

	if (col == sorter.getTopPriority())
	sorter.reverseTopPriority();
	else
	sorter.setTopPriority(col);

	PlatformUI.getWorkbench().getDisplay().asyncExec(
	new Runnable() {
	public void run() {
	refresh();
	updateDirectionIndicator(column);
	}
	});
	}

	/**
	* Update the direction indicator as column is now the primary column.
	*
	* @param column
	*/
	protected void updateDirectionIndicator(TreeColumn column) {
	getTree().setSortColumn(column);
	if (((ServerViewerComparator) getComparator()).getTopPriorityDirection() == ServerViewerComparator.ASCENDING)
	getTree().setSortDirection(SWT.UP);
	else
	getTree().setSortDirection(SWT.DOWN);
	}

	protected Object[] adaptLabelChangeObjects(Object[] obj) {
	if (obj == null)
	return obj;

	List<Object> list = new ArrayList<Object>();
	int size = obj.length;
	for (int i = 0; i < size; i++) {
	if (obj[i] instanceof IModule) {
	list.add(obj[i]);
	} else if (obj[i] instanceof IServer) {
	list.add(obj[i]);
	} else if (obj[i] instanceof ModuleServer) {
	list.add(obj[i]);
	} else if (obj[i] instanceof IProject) {
	IProject proj = (IProject) obj[i];

	List<Object> list2 = new ArrayList<Object>();
	getTreeChildren(list2, view.treeTable);

	Iterator iterator = list2.iterator();
	while (iterator.hasNext()) {
	Object o = iterator.next();
	if (o instanceof ModuleServer) {
	ModuleServer ms = (ModuleServer) o;
	if (proj.equals(ms.module[ms.module.length - 1].getProject()))
	list.add(ms);
	}
	}
	}
	}

	Object[] o = new Object[list.size()];
	list.toArray(o);
	return o;
	}

	private void getTreeChildren(List<Object> list, Widget widget) {
	Item[] items = getChildren(widget);
	for (int i = 0; i < items.length; i++) {
	Item item = items[i];
	Object data = item.getData();
	if (data != null)
	list.add(data);

	if (getExpanded(item)) {
	// only recurse if it is expanded - if
	// not then the children aren't visible
	getTreeChildren(list, item);
	}
	}
	}

	protected void addListeners() {
	serverResourceListener = new IServerLifecycleListener() {
	public void serverAdded(IServer server) {
	addServer(server);
	server.addServerListener(serverListener);
	((Server) server).addPublishListener(publishListener);
	}
	public void serverChanged(IServer server) {
	refreshServer(server);
	}
	public void serverRemoved(IServer server) {
	removeServer(server);
	server.removeServerListener(serverListener);
	((Server) server).removePublishListener(publishListener);
	}
	};
	ServerCore.addServerLifecycleListener(serverResourceListener);

	publishListener = new PublishAdapter() {
	public void publishStarted(IServer server) {
	handlePublishChange(server, true);
	}

	public void publishFinished(IServer server, IStatus status) {
	handlePublishChange(server, false);
	}
	};

	serverListener = new IServerListener() {
	public void serverChanged(ServerEvent event) {
	if (event == null)
	return;

	int eventKind = event.getKind();
	IServer server = event.getServer();
	if ((eventKind & ServerEvent.SERVER_CHANGE) != 0) {
	// server change event
	if ((eventKind & ServerEvent.STATE_CHANGE) != 0) {
	refreshServer(server);
	int state = event.getState();
	String id = server.getId();
	if (state == IServer.STATE_STARTING \|\| state == IServer.STATE_STOPPING) {
	boolean startThread = false;
	synchronized (starting) {
	if (!starting.contains(id)) {
	if (starting.isEmpty())
	startThread = true;
	starting.add(id);
	}
	}
	if (startThread)
	startThread();
	} else {
	boolean stopThread = false;
	synchronized (starting) {
	if (starting.contains(id)) {
	starting.remove(id);
	if (starting.isEmpty())
	stopThread = true;
	}
	}
	if (stopThread)
	stopThread();
	}
	} else
	refreshServer(server);
	} else if ((eventKind & ServerEvent.MODULE_CHANGE) != 0) {
	// module change event
	if ((eventKind & ServerEvent.STATE_CHANGE) != 0 \|\| (eventKind & ServerEvent.PUBLISH_STATE_CHANGE) != 0) {
	refreshServer(server);
	}
	}
	}
	};

	// add listeners to servers
	IServer[] servers = ServerCore.getServers();
	if (servers != null) {
	int size = servers.length;
	for (int i = 0; i < size; i++) {
	servers[i].addServerListener(serverListener);
	((Server) servers[i]).addPublishListener(publishListener);
	}
	}
	}

	/**
	* @param server
	* @deprecated With the introduction of the CNF this method shouldn't be called
	*/
	protected void refreshServer(final IServer server) {
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	try {
	refresh(server);
	ISelection sel = ServerTableViewer.this.getSelection();
	ServerTableViewer.this.setSelection(sel);
	} catch (Exception e) {
	// ignore
	}
	}
	});
	}

	protected void handleDispose(DisposeEvent event) {
	stopThread();
	//if (dsListener != null)
	// view.getViewSite().getPage().removeSelectionListener(dsListener);

	ServerCore.removeServerLifecycleListener(serverResourceListener);

	// remove listeners from server
	IServer[] servers = ServerCore.getServers();
	if (servers != null) {
	int size = servers.length;
	for (int i = 0; i < size; i++) {
	if (serverListener != null)
	servers[i].removeServerListener(serverListener);
	if (publishListener != null)
	((Server) servers[i]).removePublishListener(publishListener);
	}
	}

	clipboard.dispose();

	super.handleDispose(event);
	}

	/**
	* Called when the publish state changes.
	* @param server org.eclipse.wst.server.core.IServer
	*/
	protected void handlePublishChange(IServer server, boolean isPublishing) {
	String serverId = server.getId();
	if (isPublishing)
	publishing.add(serverId);
	else
	publishing.remove(serverId);

	refreshServer(server);
	}

	/**
	*
	*/
	protected void handleServerModulesChanged(IServer server2) {
	if (server2 == null)
	return;

	IServer[] servers = ServerCore.getServers();
	if (servers != null) {
	int size = servers.length;
	for (int i = 0; i < size; i++) {
	if (server2.equals(servers[i]))
	refresh(servers[i]);
	}
	}
	}

	/**
	* Called when an element is added.
	* @param server org.eclipse.wst.server.core.IServer
	*/
	protected void handleServerResourceAdded(IServer server) {
	add(null, server);
	}

	/*protected void handleServerResourceAdded(IServerConfiguration configuration) {
	configurationChange(configuration, true);
	}*/

	/**
	* Called when an element is changed.
	* @param server org.eclipse.wst.server.core.IServer
	*/
	protected void handleServerResourceChanged(IServer server) {
	refresh(server);
	}

	/*protected void handleServerResourceChanged(IServerConfiguration configuration) {
	IServer[] servers = ServerCore.getServers();
	if (servers != null) {
	int size = servers.length;
	for (int i = 0; i < size; i++) {
	IServerConfiguration config = servers[i].getServerConfiguration();
	if (configuration.equals(config))
	refresh(servers[i]);
	}
	}
	}*/

	/**
	* Called when an element is removed.
	* @param server org.eclipse.wst.server.core.IServer
	*/
	protected void handleServerResourceRemoved(IServer server) {
	remove(server);

	String serverId = server.getId();
	publishing.remove(serverId);

	view.getViewSite().getActionBars().getStatusLineManager().setMessage(null, null);
	}

	/*protected void handleServerResourceRemoved(IServerConfiguration configuration) {
	configurationChange(configuration, false);
	}*/

	protected void addServer(final IServer server) {
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	add(ROOT, server);
	}
	});
	}

	protected void removeServer(final IServer server) {
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	remove(server);
	}
	});
	}

	public void doUpdateItem(Widget widget, Object element, boolean fullMap) {
	if (widget instanceof TreeItem && color != null) {
	TreeItem item = (TreeItem) widget;
	if (element instanceof ModuleServer) {
	ModuleServer ms = (ModuleServer) element;
	IModule m = ms.module[ms.module.length-1];
	if (m.isExternal())
	item.setForeground(color);
	else
	item.setForeground(null);
	if (ms.server.getModulePublishState(ms.module) != IServer.PUBLISH_STATE_NONE)
	item.setFont(0, font);
	else
	item.setFont(0, null);
	}
	}
	super.doUpdateItem(widget, element, fullMap);
	}

	protected void updateAnimation(IServer server) {
	try {
	Widget widget = doFindItem(server);
	TreeItem item = (TreeItem) widget;
	item.setText(1, labelProvider.getColumnText(server, 1));
	item.setImage(1, labelProvider.getColumnImage(server, 1));
	} catch (Exception e) {
	if (Trace.WARNING) {
	Trace.trace(Trace.STRING_WARNING, "Error in optimized animation", e);
	}
	}
	}
	}