bundles/org.eclipse.wst.xml.ui/src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/TreeExtension.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2006 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.xml.ui.internal.tabletree;

 import java.util.Iterator;
 import java.util.List;
 import java.util.Vector;

 import org.eclipse.jface.viewers.CellEditor;
 import org.eclipse.jface.viewers.ICellEditorListener;
 import org.eclipse.jface.viewers.ICellModifier;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.FocusEvent;
 import org.eclipse.swt.events.FocusListener;
 import org.eclipse.swt.events.KeyAdapter;
 import org.eclipse.swt.events.KeyEvent;
 import org.eclipse.swt.events.KeyListener;
 import org.eclipse.swt.events.MouseAdapter;
 import org.eclipse.swt.events.MouseEvent;
 import org.eclipse.swt.events.MouseMoveListener;
 import org.eclipse.swt.events.PaintEvent;
 import org.eclipse.swt.events.PaintListener;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.graphics.Cursor;
 import org.eclipse.swt.graphics.GC;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.ScrollBar;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.swt.widgets.Tree;
 import org.eclipse.swt.widgets.TreeItem;
 import org.eclipse.ui.PlatformUI;


 public class TreeExtension implements PaintListener {

 	protected Tree fTree;
 	protected EditManager editManager;
 	protected String[] fColumnProperties;
 	protected ICellModifier cellModifier;
 	protected int columnPosition = 300;
 	protected int columnHitWidth = 5;
 	protected Color tableLineColor;
 	protected int controlWidth;
 	protected DelayedDrawTimer delayedDrawTimer;
 	private boolean fisUnsupportedInput = false;

 	public TreeExtension(Tree tree) {
 		this.fTree = tree;
 		InternalMouseListener listener = new InternalMouseListener();
 		tree.addMouseMoveListener(listener);
 		tree.addMouseListener(listener);
 		tree.addPaintListener(this);
 		editManager = new EditManager(tree);
 		delayedDrawTimer = new DelayedDrawTimer(tree);

 		tableLineColor = tree.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW);
 	}

 	public void dispose() {
 		tableLineColor.dispose();
 	}

 	public void setCellModifier(ICellModifier modifier) {
 		cellModifier = modifier;
 	}

 	public void resetCachedData() {
 		// todo: sure seems we should reset something?
 	}

 	public ICellModifier getCellModifier() {
 		return cellModifier;
 	}

 	public List getItemList() {
 		List list = new Vector();
 		getItemListHelper(fTree.getItems(), list);
 		return list;
 	}

 	protected void getItemListHelper(TreeItem[] items, List list) {
 		for (int i = 0; i < items.length; i++) {
 			TreeItem item = items[i];
 			list.add(item);
 			getItemListHelper(item.getItems(), list);
 		}
 	}

 	protected TreeItem getTreeItemOnRow(int px, int py) {
 		TreeItem result = null;
 		List list = getItemList();
 		for (Iterator i = list.iterator(); i.hasNext();) {
 			TreeItem item = (TreeItem) i.next();
 			Rectangle r = item.getBounds();
 			if ((r != null) && (px >= r.x) && (py >= r.y) && (py <= r.y + r.height)) {
 				result = item;
 			}
 		}
 		return result;
 	}

 	protected class InternalMouseListener extends MouseAdapter implements MouseMoveListener {
 		protected int columnDragged = -1;
 		protected boolean isDown = false;
 		protected int prevX = -1;
 		protected Cursor cursor = null;

 		public void mouseMove(MouseEvent e) {
 			if ((e.x > columnPosition - columnHitWidth) && (e.x < columnPosition + columnHitWidth)) {
 				if (cursor == null) {
 					cursor = new Cursor(fTree.getDisplay(), SWT.CURSOR_SIZEWE);
 					fTree.setCursor(cursor);
 				}
 			}
 			else {
 				if (cursor != null) {
 					fTree.setCursor(null);
 					cursor.dispose();
 					cursor = null;
 				}
 			}

 			if (columnDragged != -1) {
 				// using the delay timer will make redraws less flickery
 				if (e.x > 20) {
 					columnPosition = e.x;
 					delayedDrawTimer.reset(20);
 				}
 			}
 		}

 		public void mouseDown(MouseEvent e) {
 			// here we handle the column resizing by detect if the user has
 			// click on a column separator
 			//
 			columnDragged = -1;
 			editManager.deactivateCellEditor();

 			if ((e.x > columnPosition - columnHitWidth) && (e.x < columnPosition + columnHitWidth)) {
 				columnDragged = 0;
 			}

 			// here we handle selecting tree items when any thing on the 'row'
 			// is clicked
 			//
 			TreeItem item = fTree.getItem(new Point(e.x, e.y));
 			if (item == null) {
 				item = getTreeItemOnRow(e.x, e.y);
 				if (item != null) {
 					TreeItem[] items = new TreeItem[1];
 					items[0] = item;
 					fTree.setSelection(items);
 				}
 			}
 		}

 		public void mouseUp(MouseEvent e) {
 			columnDragged = -1;
 		}
 	}

 	public String[] getColumnProperties() {
 		return fColumnProperties;
 	}

 	public void setColumnProperties(String[] columnProperties) {
 		this.fColumnProperties = columnProperties;
 	}

 	public void paintControl(PaintEvent event) {
 		GC gc = event.gc;
 		Rectangle treeBounds = fTree.getBounds();

 		controlWidth = treeBounds.width;
 		Color bg = fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
 		Color bg2 = fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION);

 		gc.setBackground(bg2);

 		// // This next part causes problems on LINUX, so let's not do it
 		// there
 		// if (B2BHacks.IS_UNIX == false) {
 		// TreeItem[] selectedItems = tree.getSelection();
 		// if (selectedItems.length > 0) {
 		// for (int i = 0; i < selectedItems.length; i++) {
 		// TreeItem item = selectedItems[i];
 		// Rectangle bounds = item.getBounds();
 		// if (bounds != null) {
 		// gc.fillRectangle(bounds.x + bounds.width, bounds.y, controlWidth,
 		// bounds.height);
 		// }
 		// }
 		// }
 		// }
 		//
 		if (!fisUnsupportedInput) {
 			TreeItem[] items = fTree.getItems();
 			if (items.length > 0) {
 				gc.setForeground(tableLineColor);
 				gc.setBackground(bg);

 				gc.fillRectangle(columnPosition, treeBounds.x, treeBounds.width, treeBounds.height);

 				Rectangle itemBounds = items[0].getBounds();
 				int height = computeTreeItemHeight();

 				if (itemBounds != null) {
 					/*
 					 * Bounds will be for the first item, which will either be
 					 * visible at the top of the Tree, or scrolled off with
 					 * negative values
 					 */
 					int startY = itemBounds.y;

 					/* Only draw lines within the Tree boundaries */
 					for (int i = startY; i < treeBounds.height; i += height) {
 						if (i >= treeBounds.y) {
 							gc.drawLine(0, i, treeBounds.width, i);
 						}
 					}
 				}
 				gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
 				paintItems(gc, items, treeBounds);

 			}
 			else {
 				addEmptyTreeMessage(gc);
 			}
 		}
 		else {
 			addUnableToPopulateTreeMessage(gc);
 		}
 	}

 	protected int computeTreeItemHeight() {
 		int result = -1;

 		/*
 		 * On GTK tree.getItemHeight() seems to lie to us. It reports that the
 		 * tree item occupies a few pixles less vertical space than it should
 		 * (possibly because of the image height vs. the text height?). This
 		 * foils our code that draws the 'row' lines since we assume that
 		 * lines should be drawn at 'itemHeight' increments. Don't trust
 		 * getItemHeight() to compute the increment... instead compute the
 		 * value based on distance between two TreeItems, and then use the
 		 * larger value.
 		 *
 		 * This strategy only works on trees where the items are of even
 		 * height, however bug
 		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=117201 indicates that
 		 * this is no longer promised, at least on win32 and likely on other
 		 * platforms soon.
 		 */
 		if (fTree.getItemCount() > 0) {
 			TreeItem[] items = fTree.getItems();
 			Rectangle itemBounds = items[0].getBounds();

 			if (items[0].getExpanded()) {
 				TreeItem[] children = items[0].getItems();
 				if (children.length > 0) {
 					result = children[0].getBounds().y - itemBounds.y;
 				}
 			}
 			else if (items.length > 1) {
 				result = items[1].getBounds().y - itemBounds.y;
 			}
 		}

 		result = Math.max(fTree.getItemHeight(), result);
 		return result;
 	}

 	protected void addEmptyTreeMessage(GC gc) {
 		// nothing to add here
 	}

 	private void addUnableToPopulateTreeMessage(GC gc) {
 		// here we print a message when the document cannot be displayed just
 		// to give the
 		// user a visual cue
 		// so that they know how to proceed to edit the blank view
 		gc.setForeground(fTree.getDisplay().getSystemColor(SWT.COLOR_BLACK));
 		gc.setBackground(fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
 		gc.drawString(XMLEditorMessages.TreeExtension_0, 10, 10);
 	}

 	void setIsUnsupportedInput(boolean isUnsupported) {
 		fisUnsupportedInput = isUnsupported;
 	}

 	public void paintItems(GC gc, TreeItem[] items, Rectangle treeBounds) {
 		if (items != null) {
 			for (int i = 0; i < items.length; i++) {
 				TreeItem item = items[i];
 				if (item != null) {
 					Rectangle bounds = item.getBounds();
 					if (bounds != null) {
 						if (treeBounds.intersects(bounds)) {
 							paintItem(gc, item, bounds);
 						}
 					}

 					// defect 241039
 					//
 					if (item.getExpanded()) {
 						paintItems(gc, item.getItems(), treeBounds);
 					}
 				}
 			}
 		}
 	}

 	protected void paintItem(GC gc, TreeItem item, Rectangle bounds) {
 		// nothing to paint
 	}

 	public interface ICellEditorProvider {
 		CellEditor getCellEditor(Object o, int col);
 	}

 	/**
 	 * This class is used to improve drawing during a column resize.
 	 */
 	public class DelayedDrawTimer implements Runnable {
 		protected Control control;

 		public DelayedDrawTimer(Control control1) {
 			this.control = control1;
 		}

 		public void reset(int milliseconds) {
 			getDisplay().timerExec(milliseconds, this);
 		}

 		public void run() {
 			control.redraw();
 		}
 	}

 	Display getDisplay() {

 		return PlatformUI.getWorkbench().getDisplay();
 	}

 	/**
 	 * EditManager
 	 */
 	public class EditManager {
 		protected Tree fTree1;
 		protected Control cellEditorHolder;
 		protected CellEditorState cellEditorState;

 		public EditManager(Tree tree) {
 			this.fTree1 = tree;
 			this.cellEditorHolder = new Composite(tree, SWT.NONE);

 			final Tree theTree = tree;

 			MouseAdapter theMouseAdapter = new MouseAdapter() {
 				public void mouseDown(MouseEvent e) {
 					deactivateCellEditor();

 					if (e.x > columnPosition + columnHitWidth) {
 						TreeItem[] items = theTree.getSelection();
 						// No edit if more than one row is selected.
 						if (items.length == 1) {
 							Rectangle bounds = items[0].getBounds();
 							if ((bounds != null) && (e.y >= bounds.y) && (e.y <= bounds.y + bounds.height)) {
 								int columnToEdit = 1;
 								activateCellEditor(items[0], columnToEdit);
 							}
 						}
 					}
 				}
 			};

 			SelectionListener selectionListener = new SelectionListener() {
 				public void widgetDefaultSelected(SelectionEvent e) {
 					applyCellEditorValue();
 				}

 				public void widgetSelected(SelectionEvent e) {
 					applyCellEditorValue();
 				}
 			};

 			KeyListener keyListener = new KeyAdapter() {
 				public void keyPressed(KeyEvent e) {
 					if (e.character == SWT.CR) {
 						deactivateCellEditor();
 						TreeItem[] items = theTree.getSelection();
 						if (items.length == 1) {
 							activateCellEditor(items[0], 1);
 						}
 					}
 				}
 			};

 			tree.addMouseListener(theMouseAdapter);
 			tree.addKeyListener(keyListener);
 			ScrollBar hBar = tree.getHorizontalBar();
 			if (hBar != null) {
 				hBar.addSelectionListener(selectionListener);
 			}
 			ScrollBar vBar = tree.getVerticalBar();
 			if (vBar != null) {
 				vBar.addSelectionListener(selectionListener);
 			}
 		}

 		public boolean isCellEditorActive() {
 			return cellEditorState != null;
 		}

 		public void applyCellEditorValue() {
 			if ((cellEditorState != null) && (cellModifier != null)) {
 				TreeItem treeItem = cellEditorState.fTreeItem;

 				// The area below the cell editor needs to be explicity
 				// repainted on Linux
 				//
 				// Rectangle r = B2BHacks.IS_UNIX ? treeItem.getBounds() :
 				// null;

 				Object value = cellEditorState.fCellEditor.getValue();
 				String property = cellEditorState.fProperty;

 				deactivateCellEditor();

 				cellModifier.modify(treeItem, property, value);

 				// if (r != null) {
 				// tree.redraw(r.x, r.y, tree.getBounds().width, r.height,
 				// false);
 				// }
 			}
 		}

 		public void deactivateCellEditor() {
 			// Clean up any previous editor control
 			if (cellEditorState != null) {
 				cellEditorState.deactivate();
 				cellEditorState = null;
 			}
 		}

 		public void activateCellEditor(TreeItem treeItem, int column) {
 			if (cellModifier instanceof ICellEditorProvider) {
 				ICellEditorProvider cellEditorProvider = (ICellEditorProvider) cellModifier;
 				Object data = treeItem.getData();
 				if (fColumnProperties.length > column) {
 					String property = fColumnProperties[column];
 					if (cellModifier.canModify(data, property)) {
 						CellEditor newCellEditor = cellEditorProvider.getCellEditor(data, column);
 						if (newCellEditor != null) {
 							// The control that will be the editor must be a
 							// child of the columnPosition
 							Control control = newCellEditor.getControl();
 							if (control != null) {
 								cellEditorState = new CellEditorState(newCellEditor, control, treeItem, column, property);
 								cellEditorState.activate();
 							}
 						}
 					}
 				}
 			}
 		}

 		/**
 		 * this class holds the state that is need on a per cell editor
 		 * invocation basis
 		 */
 		public class CellEditorState implements ICellEditorListener, FocusListener {
 			public CellEditor fCellEditor;
 			public Control fControl;
 			public TreeItem fTreeItem;
 			public int fColumnNumber;
 			public String fProperty;

 			public CellEditorState(CellEditor cellEditor, Control control, TreeItem treeItem, int columnNumber, String property) {
 				this.fCellEditor = cellEditor;
 				this.fControl = control;
 				this.fTreeItem = treeItem;
 				this.fColumnNumber = columnNumber;
 				this.fProperty = property;
 			}

 			public void activate() {
 				Object element = fTreeItem.getData();
 				String value = cellModifier.getValue(element, fProperty).toString();
 				if (fControl instanceof Text) {
 					Text text = (Text) fControl;
 					int requiredSize = value.length() + 100;
 					if (text.getTextLimit() < requiredSize) {
 						text.setTextLimit(requiredSize);
 					}
 				}
 				Rectangle r = fTreeItem.getBounds();
 				if (r != null) {
 					fControl.setBounds(columnPosition + 5, r.y + 1, fTree1.getClientArea().width - (columnPosition + 5), r.height - 1);
 					fControl.setVisible(true);
 					fCellEditor.setValue(value);
 					fCellEditor.addListener(this);
 					fCellEditor.setFocus();
 					fControl.addFocusListener(this);
 				}
 			}

 			public void deactivate() {
 				fCellEditor.removeListener(this);
 				fControl.removeFocusListener(this);
 				fCellEditor.deactivate();
 				fTree1.forceFocus();
 			}

 			// ICellEditorListener methods
 			//
 			public void applyEditorValue() {
 				applyCellEditorValue();
 			}

 			public void cancelEditor() {
 				deactivateCellEditor();
 			}

 			public void editorValueChanged(boolean oldValidState, boolean newValidState) {
 				// nothing, for now
 			}

 			// FocusListener methods
 			//
 			public void focusGained(FocusEvent e) {
 				// do nothing
 			}

 			public void focusLost(FocusEvent e) {
 				applyCellEditorValue();
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2006 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.xml.ui.internal.tabletree;

	import java.util.Iterator;
	import java.util.List;
	import java.util.Vector;

	import org.eclipse.jface.viewers.CellEditor;
	import org.eclipse.jface.viewers.ICellEditorListener;
	import org.eclipse.jface.viewers.ICellModifier;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.events.FocusEvent;
	import org.eclipse.swt.events.FocusListener;
	import org.eclipse.swt.events.KeyAdapter;
	import org.eclipse.swt.events.KeyEvent;
	import org.eclipse.swt.events.KeyListener;
	import org.eclipse.swt.events.MouseAdapter;
	import org.eclipse.swt.events.MouseEvent;
	import org.eclipse.swt.events.MouseMoveListener;
	import org.eclipse.swt.events.PaintEvent;
	import org.eclipse.swt.events.PaintListener;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.events.SelectionListener;
	import org.eclipse.swt.graphics.Color;
	import org.eclipse.swt.graphics.Cursor;
	import org.eclipse.swt.graphics.GC;
	import org.eclipse.swt.graphics.Point;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.ScrollBar;
	import org.eclipse.swt.widgets.Text;
	import org.eclipse.swt.widgets.Tree;
	import org.eclipse.swt.widgets.TreeItem;
	import org.eclipse.ui.PlatformUI;


	public class TreeExtension implements PaintListener {

	protected Tree fTree;
	protected EditManager editManager;
	protected String[] fColumnProperties;
	protected ICellModifier cellModifier;
	protected int columnPosition = 300;
	protected int columnHitWidth = 5;
	protected Color tableLineColor;
	protected int controlWidth;
	protected DelayedDrawTimer delayedDrawTimer;
	private boolean fisUnsupportedInput = false;

	public TreeExtension(Tree tree) {
	this.fTree = tree;
	InternalMouseListener listener = new InternalMouseListener();
	tree.addMouseMoveListener(listener);
	tree.addMouseListener(listener);
	tree.addPaintListener(this);
	editManager = new EditManager(tree);
	delayedDrawTimer = new DelayedDrawTimer(tree);

	tableLineColor = tree.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW);
	}

	public void dispose() {
	tableLineColor.dispose();
	}

	public void setCellModifier(ICellModifier modifier) {
	cellModifier = modifier;
	}

	public void resetCachedData() {
	// todo: sure seems we should reset something?
	}

	public ICellModifier getCellModifier() {
	return cellModifier;
	}

	public List getItemList() {
	List list = new Vector();
	getItemListHelper(fTree.getItems(), list);
	return list;
	}

	protected void getItemListHelper(TreeItem[] items, List list) {
	for (int i = 0; i < items.length; i++) {
	TreeItem item = items[i];
	list.add(item);
	getItemListHelper(item.getItems(), list);
	}
	}

	protected TreeItem getTreeItemOnRow(int px, int py) {
	TreeItem result = null;
	List list = getItemList();
	for (Iterator i = list.iterator(); i.hasNext();) {
	TreeItem item = (TreeItem) i.next();
	Rectangle r = item.getBounds();
	if ((r != null) && (px >= r.x) && (py >= r.y) && (py <= r.y + r.height)) {
	result = item;
	}
	}
	return result;
	}

	protected class InternalMouseListener extends MouseAdapter implements MouseMoveListener {
	protected int columnDragged = -1;
	protected boolean isDown = false;
	protected int prevX = -1;
	protected Cursor cursor = null;

	public void mouseMove(MouseEvent e) {
	if ((e.x > columnPosition - columnHitWidth) && (e.x < columnPosition + columnHitWidth)) {
	if (cursor == null) {
	cursor = new Cursor(fTree.getDisplay(), SWT.CURSOR_SIZEWE);
	fTree.setCursor(cursor);
	}
	}
	else {
	if (cursor != null) {
	fTree.setCursor(null);
	cursor.dispose();
	cursor = null;
	}
	}

	if (columnDragged != -1) {
	// using the delay timer will make redraws less flickery
	if (e.x > 20) {
	columnPosition = e.x;
	delayedDrawTimer.reset(20);
	}
	}
	}

	public void mouseDown(MouseEvent e) {
	// here we handle the column resizing by detect if the user has
	// click on a column separator
	//
	columnDragged = -1;
	editManager.deactivateCellEditor();

	if ((e.x > columnPosition - columnHitWidth) && (e.x < columnPosition + columnHitWidth)) {
	columnDragged = 0;
	}

	// here we handle selecting tree items when any thing on the 'row'
	// is clicked
	//
	TreeItem item = fTree.getItem(new Point(e.x, e.y));
	if (item == null) {
	item = getTreeItemOnRow(e.x, e.y);
	if (item != null) {
	TreeItem[] items = new TreeItem[1];
	items[0] = item;
	fTree.setSelection(items);
	}
	}
	}

	public void mouseUp(MouseEvent e) {
	columnDragged = -1;
	}
	}

	public String[] getColumnProperties() {
	return fColumnProperties;
	}

	public void setColumnProperties(String[] columnProperties) {
	this.fColumnProperties = columnProperties;
	}

	public void paintControl(PaintEvent event) {
	GC gc = event.gc;
	Rectangle treeBounds = fTree.getBounds();

	controlWidth = treeBounds.width;
	Color bg = fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
	Color bg2 = fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION);

	gc.setBackground(bg2);

	// // This next part causes problems on LINUX, so let's not do it
	// there
	// if (B2BHacks.IS_UNIX == false) {
	// TreeItem[] selectedItems = tree.getSelection();
	// if (selectedItems.length > 0) {
	// for (int i = 0; i < selectedItems.length; i++) {
	// TreeItem item = selectedItems[i];
	// Rectangle bounds = item.getBounds();
	// if (bounds != null) {
	// gc.fillRectangle(bounds.x + bounds.width, bounds.y, controlWidth,
	// bounds.height);
	// }
	// }
	// }
	// }
	//
	if (!fisUnsupportedInput) {
	TreeItem[] items = fTree.getItems();
	if (items.length > 0) {
	gc.setForeground(tableLineColor);
	gc.setBackground(bg);

	gc.fillRectangle(columnPosition, treeBounds.x, treeBounds.width, treeBounds.height);

	Rectangle itemBounds = items[0].getBounds();
	int height = computeTreeItemHeight();

	if (itemBounds != null) {
	/*
	* Bounds will be for the first item, which will either be
	* visible at the top of the Tree, or scrolled off with
	* negative values
	*/
	int startY = itemBounds.y;

	/* Only draw lines within the Tree boundaries */
	for (int i = startY; i < treeBounds.height; i += height) {
	if (i >= treeBounds.y) {
	gc.drawLine(0, i, treeBounds.width, i);
	}
	}
	}
	gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
	paintItems(gc, items, treeBounds);

	}
	else {
	addEmptyTreeMessage(gc);
	}
	}
	else {
	addUnableToPopulateTreeMessage(gc);
	}
	}

	protected int computeTreeItemHeight() {
	int result = -1;

	/*
	* On GTK tree.getItemHeight() seems to lie to us. It reports that the
	* tree item occupies a few pixles less vertical space than it should
	* (possibly because of the image height vs. the text height?). This
	* foils our code that draws the 'row' lines since we assume that
	* lines should be drawn at 'itemHeight' increments. Don't trust
	* getItemHeight() to compute the increment... instead compute the
	* value based on distance between two TreeItems, and then use the
	* larger value.
	*
	* This strategy only works on trees where the items are of even
	* height, however bug
	* https://bugs.eclipse.org/bugs/show_bug.cgi?id=117201 indicates that
	* this is no longer promised, at least on win32 and likely on other
	* platforms soon.
	*/
	if (fTree.getItemCount() > 0) {
	TreeItem[] items = fTree.getItems();
	Rectangle itemBounds = items[0].getBounds();

	if (items[0].getExpanded()) {
	TreeItem[] children = items[0].getItems();
	if (children.length > 0) {
	result = children[0].getBounds().y - itemBounds.y;
	}
	}
	else if (items.length > 1) {
	result = items[1].getBounds().y - itemBounds.y;
	}
	}

	result = Math.max(fTree.getItemHeight(), result);
	return result;
	}

	protected void addEmptyTreeMessage(GC gc) {
	// nothing to add here
	}

	private void addUnableToPopulateTreeMessage(GC gc) {
	// here we print a message when the document cannot be displayed just
	// to give the
	// user a visual cue
	// so that they know how to proceed to edit the blank view
	gc.setForeground(fTree.getDisplay().getSystemColor(SWT.COLOR_BLACK));
	gc.setBackground(fTree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
	gc.drawString(XMLEditorMessages.TreeExtension_0, 10, 10);
	}

	void setIsUnsupportedInput(boolean isUnsupported) {
	fisUnsupportedInput = isUnsupported;
	}

	public void paintItems(GC gc, TreeItem[] items, Rectangle treeBounds) {
	if (items != null) {
	for (int i = 0; i < items.length; i++) {
	TreeItem item = items[i];
	if (item != null) {
	Rectangle bounds = item.getBounds();
	if (bounds != null) {
	if (treeBounds.intersects(bounds)) {
	paintItem(gc, item, bounds);
	}
	}

	// defect 241039
	//
	if (item.getExpanded()) {
	paintItems(gc, item.getItems(), treeBounds);
	}
	}
	}
	}
	}

	protected void paintItem(GC gc, TreeItem item, Rectangle bounds) {
	// nothing to paint
	}

	public interface ICellEditorProvider {
	CellEditor getCellEditor(Object o, int col);
	}

	/**
	* This class is used to improve drawing during a column resize.
	*/
	public class DelayedDrawTimer implements Runnable {
	protected Control control;

	public DelayedDrawTimer(Control control1) {
	this.control = control1;
	}

	public void reset(int milliseconds) {
	getDisplay().timerExec(milliseconds, this);
	}

	public void run() {
	control.redraw();
	}
	}

	Display getDisplay() {

	return PlatformUI.getWorkbench().getDisplay();
	}

	/**
	* EditManager
	*/
	public class EditManager {
	protected Tree fTree1;
	protected Control cellEditorHolder;
	protected CellEditorState cellEditorState;

	public EditManager(Tree tree) {
	this.fTree1 = tree;
	this.cellEditorHolder = new Composite(tree, SWT.NONE);

	final Tree theTree = tree;

	MouseAdapter theMouseAdapter = new MouseAdapter() {
	public void mouseDown(MouseEvent e) {
	deactivateCellEditor();

	if (e.x > columnPosition + columnHitWidth) {
	TreeItem[] items = theTree.getSelection();
	// No edit if more than one row is selected.
	if (items.length == 1) {
	Rectangle bounds = items[0].getBounds();
	if ((bounds != null) && (e.y >= bounds.y) && (e.y <= bounds.y + bounds.height)) {
	int columnToEdit = 1;
	activateCellEditor(items[0], columnToEdit);
	}
	}
	}
	}
	};

	SelectionListener selectionListener = new SelectionListener() {
	public void widgetDefaultSelected(SelectionEvent e) {
	applyCellEditorValue();
	}

	public void widgetSelected(SelectionEvent e) {
	applyCellEditorValue();
	}
	};

	KeyListener keyListener = new KeyAdapter() {
	public void keyPressed(KeyEvent e) {
	if (e.character == SWT.CR) {
	deactivateCellEditor();
	TreeItem[] items = theTree.getSelection();
	if (items.length == 1) {
	activateCellEditor(items[0], 1);
	}
	}
	}
	};

	tree.addMouseListener(theMouseAdapter);
	tree.addKeyListener(keyListener);
	ScrollBar hBar = tree.getHorizontalBar();
	if (hBar != null) {
	hBar.addSelectionListener(selectionListener);
	}
	ScrollBar vBar = tree.getVerticalBar();
	if (vBar != null) {
	vBar.addSelectionListener(selectionListener);
	}
	}

	public boolean isCellEditorActive() {
	return cellEditorState != null;
	}

	public void applyCellEditorValue() {
	if ((cellEditorState != null) && (cellModifier != null)) {
	TreeItem treeItem = cellEditorState.fTreeItem;

	// The area below the cell editor needs to be explicity
	// repainted on Linux
	//
	// Rectangle r = B2BHacks.IS_UNIX ? treeItem.getBounds() :
	// null;

	Object value = cellEditorState.fCellEditor.getValue();
	String property = cellEditorState.fProperty;

	deactivateCellEditor();

	cellModifier.modify(treeItem, property, value);

	// if (r != null) {
	// tree.redraw(r.x, r.y, tree.getBounds().width, r.height,
	// false);
	// }
	}
	}

	public void deactivateCellEditor() {
	// Clean up any previous editor control
	if (cellEditorState != null) {
	cellEditorState.deactivate();
	cellEditorState = null;
	}
	}

	public void activateCellEditor(TreeItem treeItem, int column) {
	if (cellModifier instanceof ICellEditorProvider) {
	ICellEditorProvider cellEditorProvider = (ICellEditorProvider) cellModifier;
	Object data = treeItem.getData();
	if (fColumnProperties.length > column) {
	String property = fColumnProperties[column];
	if (cellModifier.canModify(data, property)) {
	CellEditor newCellEditor = cellEditorProvider.getCellEditor(data, column);
	if (newCellEditor != null) {
	// The control that will be the editor must be a
	// child of the columnPosition
	Control control = newCellEditor.getControl();
	if (control != null) {
	cellEditorState = new CellEditorState(newCellEditor, control, treeItem, column, property);
	cellEditorState.activate();
	}
	}
	}
	}
	}
	}

	/**
	* this class holds the state that is need on a per cell editor
	* invocation basis
	*/
	public class CellEditorState implements ICellEditorListener, FocusListener {
	public CellEditor fCellEditor;
	public Control fControl;
	public TreeItem fTreeItem;
	public int fColumnNumber;
	public String fProperty;

	public CellEditorState(CellEditor cellEditor, Control control, TreeItem treeItem, int columnNumber, String property) {
	this.fCellEditor = cellEditor;
	this.fControl = control;
	this.fTreeItem = treeItem;
	this.fColumnNumber = columnNumber;
	this.fProperty = property;
	}

	public void activate() {
	Object element = fTreeItem.getData();
	String value = cellModifier.getValue(element, fProperty).toString();
	if (fControl instanceof Text) {
	Text text = (Text) fControl;
	int requiredSize = value.length() + 100;
	if (text.getTextLimit() < requiredSize) {
	text.setTextLimit(requiredSize);
	}
	}
	Rectangle r = fTreeItem.getBounds();
	if (r != null) {
	fControl.setBounds(columnPosition + 5, r.y + 1, fTree1.getClientArea().width - (columnPosition + 5), r.height - 1);
	fControl.setVisible(true);
	fCellEditor.setValue(value);
	fCellEditor.addListener(this);
	fCellEditor.setFocus();
	fControl.addFocusListener(this);
	}
	}

	public void deactivate() {
	fCellEditor.removeListener(this);
	fControl.removeFocusListener(this);
	fCellEditor.deactivate();
	fTree1.forceFocus();
	}

	// ICellEditorListener methods
	//
	public void applyEditorValue() {
	applyCellEditorValue();
	}

	public void cancelEditor() {
	deactivateCellEditor();
	}

	public void editorValueChanged(boolean oldValidState, boolean newValidState) {
	// nothing, for now
	}

	// FocusListener methods
	//
	public void focusGained(FocusEvent e) {
	// do nothing
	}

	public void focusLost(FocusEvent e) {
	applyCellEditorValue();
	}
	}
	}
	}