projects/dwt2: org.eclipse.swt.gtk.linux.x86/src/org/eclipse/swt/widgets/Tree.d comparison

comparison org.eclipse.swt.gtk.linux.x86/src/org/eclipse/swt/widgets/Tree.d @ 25:f713da8bc051

Added SWT Linux GTK

author	Frank Benoit <benoit@tionex.de>
date	Fri, 20 Mar 2009 23:03:58 +0100
parents
children	b397a43d66d1

comparison

equal deleted inserted replaced

-:b7a1d02a0e1f
+:f713da8bc051
+/*******************************************************************************
+* Copyright (c) 2000, 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
+* Port to the D programming language:
+*     Frank Benoit <benoit@tionex.de>
+*******************************************************************************/
+module org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.SWTException;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.events.TreeListener;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.internal.gtk.OS;
+import org.eclipse.swt.widgets.TreeItem;
+import org.eclipse.swt.widgets.TreeColumn;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.ImageList;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Decorations;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.ScrollBar;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.TypedListener;
+import java.lang.all;
+/**
+* Instances of this class provide a selectable user interface object
+* that displays a hierarchy of items and issues notification when an
+* item in the hierarchy is selected.
+* <p>
+* The item children that may be added to instances of this class
+* must be of type <code>TreeItem</code>.
+* </p><p>
+* Style <code>VIRTUAL</code> is used to create a <code>Tree</code> whose
+* <code>TreeItem</code>s are to be populated by the client on an on-demand basis
+* instead of up-front.  This can provide significant performance improvements for
+* trees that are very large or for which <code>TreeItem</code> population is
+* expensive (for example, retrieving values from an external source).
+* </p><p>
+* Here is an example of using a <code>Tree</code> with style <code>VIRTUAL</code>:
+* <code><pre>
+*  final Tree tree = new Tree(parent, SWT.VIRTUAL | SWT.BORDER);
+*  tree.setItemCount(20);
+*  tree.addListener(SWT.SetData, new Listener() {
+*      public void handleEvent(Event event) {
+*          TreeItem item = (TreeItem)event.item;
+*          TreeItem parentItem = item.getParentItem();
+*          String text = null;
+*          if (parentItem is null) {
+*              text = "node " + tree.indexOf(item);
+*          } else {
+*              text = parentItem.getText() + " - " + parentItem.indexOf(item);
+*          }
+*          item.setText(text);
+*          System.out.println(text);
+*          item.setItemCount(10);
+*      }
+*  });
+* </pre></code>
+* </p><p>
+* Note that although this class is a subclass of <code>Composite</code>,
+* it does not normally make sense to add <code>Control</code> children to
+* it, or set a layout on it, unless implementing something like a cell
+* editor.
+* </p><p>
+* <dl>
+* <dt><b>Styles:</b></dt>
+* <dd>SINGLE, MULTI, CHECK, FULL_SELECTION, VIRTUAL, NO_SCROLL</dd>
+* <dt><b>Events:</b></dt>
+* <dd>Selection, DefaultSelection, Collapse, Expand, SetData, MeasureItem, EraseItem, PaintItem</dd>
+* </dl>
+* </p><p>
+* Note: Only one of the styles SINGLE and MULTI may be specified.
+* </p><p>
+* IMPORTANT: This class is <em>not</em> intended to be subclassed.
+* </p>
+*
+* @see <a href="http://www.eclipse.org/swt/snippets/#tree">Tree, TreeItem, TreeColumn snippets</a>
+* @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: ControlExample</a>
+* @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
+*/
+public class Tree : Composite {
+alias Composite.computeSize computeSize;
+alias Composite.createHandle createHandle;
+alias Composite.dragDetect dragDetect;
+alias Composite.mnemonicHit mnemonicHit;
+alias Composite.mnemonicMatch mnemonicMatch;
+alias Composite.setBackgroundColor setBackgroundColor;
+alias Composite.setBounds setBounds;
+CallbackData treeSelectionCallbackData;
+GtkTreeStore* modelHandle;
+GtkCellRenderer* checkRenderer;
+int columnCount, sortDirection;
+GtkWidget* ignoreCell;
+TreeItem[] items;
+TreeColumn [] columns;
+TreeColumn sortColumn;
+TreeItem currentItem;
+ImageList imageList, headerImageList;
+bool firstCustomDraw;
+bool modelChanged;
+bool expandAll;
+int drawState, drawFlags;
+GdkColor* drawForeground;
+bool ownerDraw, ignoreSize;
+static const int ID_COLUMN = 0;
+static const int CHECKED_COLUMN = 1;
+static const int GRAYED_COLUMN = 2;
+static const int FOREGROUND_COLUMN = 3;
+static const int BACKGROUND_COLUMN = 4;
+static const int FONT_COLUMN = 5;
+static const int FIRST_COLUMN = FONT_COLUMN + 1;
+static const int CELL_PIXBUF = 0;
+static const int CELL_TEXT = 1;
+static const int CELL_FOREGROUND = 2;
+static const int CELL_BACKGROUND = 3;
+static const int CELL_FONT = 4;
+static const int CELL_TYPES = CELL_FONT + 1;
+/**
+* Constructs a new instance of this class given its parent
+* and a style value describing its behavior and appearance.
+* <p>
+* The style value is either one of the style constants defined in
+* class <code>SWT</code> which is applicable to instances of this
+* class, or must be built by <em>bitwise OR</em>'ing together
+* (that is, using the <code>int</code> "|" operator) two or more
+* of those <code>SWT</code> style constants. The class description
+* lists the style constants that are applicable to the class.
+* Style bits are also inherited from superclasses.
+* </p>
+*
+* @param parent a composite control which will be the parent of the new instance (cannot be null)
+* @param style the style of control to construct
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
+*    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
+* </ul>
+*
+* @see SWT#SINGLE
+* @see SWT#MULTI
+* @see SWT#CHECK
+* @see SWT#FULL_SELECTION
+* @see SWT#VIRTUAL
+* @see SWT#NO_SCROLL
+* @see Widget#checkSubclass
+* @see Widget#getStyle
+*/
+public this (Composite parent, int style) {
+super (parent, checkStyle (style));
+}
+override void _addListener (int eventType, Listener listener) {
+super._addListener (eventType, listener);
+if (!ownerDraw) {
+switch (eventType) {
+case SWT.MeasureItem:
+case SWT.EraseItem:
+case SWT.PaintItem:
+ownerDraw = true;
+recreateRenderers ();
+break;
+default:
+}
+}
+}
+TreeItem _getItem (GtkTreeIter* iter) {
+int id = getId (iter, true);
+if (items [id] !is null) return items [id];
+auto path = OS.gtk_tree_model_get_path (modelHandle, iter);
+int depth = OS.gtk_tree_path_get_depth (path);
+int [] indices = new int [depth];
+indices[] = OS.gtk_tree_path_get_indices (path)[ 0 .. depth ];
+GtkTreeIter* parentIter;
+GtkTreeIter parentIterInst;
+if (depth > 1) {
+OS.gtk_tree_path_up (path);
+parentIter = &parentIterInst;
+OS.gtk_tree_model_get_iter (modelHandle, parentIter, path);
+}
+items [id] = new TreeItem (this, parentIter, SWT.NONE, indices [indices.length -1], false);
+OS.gtk_tree_path_free (path);
+return items [id];
+}
+TreeItem _getItem (GtkTreeIter* parentIter, int index) {
+GtkTreeIter iter;
+OS.gtk_tree_model_iter_nth_child(modelHandle, &iter, parentIter, index);
+int id = getId (&iter, true);
+if (items [id] !is null) return items [id];
+return items [id] = new TreeItem (this, parentIter, SWT.NONE, index, false);
+}
+int getId (GtkTreeIter* iter, bool queryModel) {
+if (queryModel) {
+int value;
+OS.gtk_tree_model_get1 (modelHandle, iter, ID_COLUMN, cast(void**)&value);
+if (value  !is -1) return value ;
+}
+// find next available id
+int id = 0;
+while (id < items.length && items [id] !is null) id++;
+if (id is items.length) {
+TreeItem [] newItems = new TreeItem [items.length + 4];
+System.arraycopy (items, 0, newItems, 0, items.length);
+items = newItems;
+}
+OS.gtk_tree_store_set1 (modelHandle, iter, ID_COLUMN, cast(void*)id );
+return id;
+}
+static int checkStyle (int style) {
+/*
+* Feature in Windows.  Even when WS_HSCROLL or
+* WS_VSCROLL is not specified, Windows creates
+* trees and tables with scroll bars.  The fix
+* is to set H_SCROLL and V_SCROLL.
+*
+* NOTE: This code appears on all platforms so that
+* applications have consistent scroll bar behavior.
+*/
+if ((style & SWT.NO_SCROLL) is 0) {
+style |= SWT.H_SCROLL | SWT.V_SCROLL;
+}
+/* GTK is always FULL_SELECTION */
+style |= SWT.FULL_SELECTION;
+return checkBits (style, SWT.SINGLE, SWT.MULTI, 0, 0, 0, 0);
+}
+override void cellDataProc (
+GtkTreeViewColumn *tree_column,
+GtkCellRenderer *cell,
+GtkTreeModel *tree_model,
+GtkTreeIter *iter,
+void* data)
+{
+if (cell is cast(GtkCellRenderer*)ignoreCell) return;
+TreeItem item = _getItem (iter);
+if (item !is null) OS.g_object_set_qdata (cast(GObject*)cell, Display.SWT_OBJECT_INDEX2, item.handle);
+bool isPixbuf = OS.GTK_IS_CELL_RENDERER_PIXBUF (cell);
+if (!(isPixbuf || OS.GTK_IS_CELL_RENDERER_TEXT (cell))) return;
+int modelIndex = -1;
+bool customDraw = false;
+if (columnCount is 0) {
+modelIndex = Tree.FIRST_COLUMN;
+customDraw = firstCustomDraw;
+} else {
+TreeColumn column = cast(TreeColumn) display.getWidget (cast(GtkWidget*)tree_column);
+if (column !is null) {
+modelIndex = column.modelIndex;
+customDraw = column.customDraw;
+}
+}
+if (modelIndex is -1) return 0;
+bool setData = false;
+if ((style & SWT.VIRTUAL) !is 0) {
+/*
+* Feature in GTK.  On GTK before 2.4, fixed_height_mode is not
+* supported, and the tree asks for the data of all items.  The
+* fix is to only provide the data if the row is visible.
+*/
+if (OS.GTK_VERSION < OS.buildVERSION (2, 3, 2)) {
+auto path = OS.gtk_tree_model_get_path (tree_model, iter);
+OS.gtk_widget_realize (handle);
+GdkRectangle visible;
+OS.gtk_tree_view_get_visible_rect (handle, &visible);
+GdkRectangle area;
+OS.gtk_tree_view_get_cell_area (handle, path, tree_column, &area);
+OS.gtk_tree_path_free (path);
+if (area.y + area.height < 0 || area.y + visible.y > visible.y + visible.height ) {
+/* Give an image from the image list to make sure the row has
+* the correct height.
+*/
+if (imageList !is null && imageList.pixbufs.length > 0) {
+if (isPixbuf) OS.g_object_set1 (cell, OS.pixbuf.ptr, cast(int)imageList.pixbufs [0]);
+}
+return 0;
+}
+}
+if (!item.cached) {
+//lastIndexOf = index [0];
+setData = checkData (item);
+}
+}
+void* ptr;
+if (setData) {
+if (isPixbuf) {
+ptr = null;
+OS.gtk_tree_model_get1 (tree_model, iter, modelIndex + CELL_PIXBUF, &ptr);
+OS.g_object_set1 (cell, OS.pixbuf.ptr, cast(int)ptr);
+} else {
+ptr = null;
+OS.gtk_tree_model_get1 (tree_model, iter, modelIndex + CELL_TEXT, &ptr);
+if (ptr !is null) {
+OS.g_object_set1 (cell, OS.text.ptr, cast(int)ptr);
+OS.g_free (ptr);
+}
+}
+}
+if (customDraw) {
+/*
+* Bug on GTK. Gtk renders the background on top of the checkbox and pixbuf.
+* This only happens in version 2.2.1 and earlier. The fix is not to set the background.
+*/
+if (OS.GTK_VERSION > OS.buildVERSION (2, 2, 1)) {
+if (!ownerDraw) {
+ptr = null;
+OS.gtk_tree_model_get1 (tree_model, iter, modelIndex + CELL_BACKGROUND, &ptr);
+if (ptr !is null) {
+OS.g_object_set1 (cell, OS.cell_background_gdk.ptr, cast(int)ptr);
+}
+}
+}
+if (!isPixbuf) {
+ptr = null;
+OS.gtk_tree_model_get1 (tree_model, iter, modelIndex + CELL_FOREGROUND, &ptr);
+if (ptr !is null) {
+OS.g_object_set1 (cell, OS.foreground_gdk.ptr, cast(int)ptr);
+}
+ptr = null;
+OS.gtk_tree_model_get1 (tree_model, iter, modelIndex + CELL_FONT, &ptr);
+if (ptr !is null) {
+OS.g_object_set1 (cell, OS.font_desc.ptr, cast(int)ptr);
+}
+}
+}
+if (setData) {
+ignoreCell = cast(GtkWidget*)cell;
+setScrollWidth (tree_column, item);
+ignoreCell = null;
+}
+}
+bool checkData (TreeItem item) {
+if (item.cached) return true;
+if ((style & SWT.VIRTUAL) !is 0) {
+item.cached = true;
+TreeItem parentItem = item.getParentItem ();
+Event event = new Event ();
+event.item = item;
+event.index = parentItem is null ? indexOf (item) : parentItem.indexOf (item);
+int mask = OS.G_SIGNAL_MATCH_DATA | OS.G_SIGNAL_MATCH_ID;
+int signal_id = OS.g_signal_lookup (OS.row_changed.ptr, OS.gtk_tree_model_get_type ());
+OS.g_signal_handlers_block_matched (modelHandle, mask, signal_id, 0, null, null, handle);
+currentItem = item;
+sendEvent (SWT.SetData, event);
+currentItem = null;
+//widget could be disposed at this point
+if (isDisposed ()) return false;
+OS.g_signal_handlers_unblock_matched (modelHandle, mask, signal_id, 0, null, null, handle);
+if (item.isDisposed ()) return false;
+}
+return true;
+}
+protected override void checkSubclass () {
+if (!isValidSubclass ()) error (SWT.ERROR_INVALID_SUBCLASS);
+}
+/**
+* Adds the listener to the collection of listeners who will
+* be notified when the user changes the receiver's selection, by sending
+* it one of the messages defined in the <code>SelectionListener</code>
+* interface.
+* <p>
+* When <code>widgetSelected</code> is called, the item field of the event object is valid.
+* If the receiver has the <code>SWT.CHECK</code> style and the check selection changes,
+* the event object detail field contains the value <code>SWT.CHECK</code>.
+* <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
+* The item field of the event object is valid for default selection, but the detail field is not used.
+* </p>
+*
+* @param listener the listener which should be notified when the user changes the receiver's selection
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see SelectionListener
+* @see #removeSelectionListener
+* @see SelectionEvent
+*/
+public void addSelectionListener (SelectionListener listener) {
+checkWidget ();
+if (listener is null) error (SWT.ERROR_NULL_ARGUMENT);
+TypedListener typedListener = new TypedListener (listener);
+addListener (SWT.Selection, typedListener);
+addListener (SWT.DefaultSelection, typedListener);
+}
+/**
+* Adds the listener to the collection of listeners who will
+* be notified when an item in the receiver is expanded or collapsed
+* by sending it one of the messages defined in the <code>TreeListener</code>
+* interface.
+*
+* @param listener the listener which should be notified
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see TreeListener
+* @see #removeTreeListener
+*/
+public void addTreeListener(TreeListener listener) {
+checkWidget ();
+if (listener is null) error (SWT.ERROR_NULL_ARGUMENT);
+TypedListener typedListener = new TypedListener (listener);
+addListener (SWT.Expand, typedListener);
+addListener (SWT.Collapse, typedListener);
+}
+int calculateWidth (GtkTreeViewColumn *column, GtkTreeIter* iter, bool recurse) {
+OS.gtk_tree_view_column_cell_set_cell_data (column, modelHandle, iter, false, false);
+/*
+* Bug in GTK.  The width calculated by gtk_tree_view_column_cell_get_size()
+* always grows in size regardless of the text or images in the table.
+* The fix is to determine the column width from the cell renderers.
+*/
+// Code intentionally commented
+//int [] width = new int [1];
+//OS.gtk_tree_view_column_cell_get_size (column, null, null, null, width, null);
+//return width [0];
+int width = 0;
+int w;
+GtkTreePath* path = null;
+if (OS.gtk_tree_view_get_expander_column (handle) is column) {
+/* indent */
+GdkRectangle rect;
+OS.gtk_widget_realize (handle);
+path = OS.gtk_tree_model_get_path (modelHandle, iter);
+OS.gtk_tree_view_get_cell_area (handle, path, column, &rect);
+width += rect.x;
+/* expander */
+OS.gtk_widget_style_get1 (handle, OS.expander_size.ptr, &w);
+width += w  + TreeItem.EXPANDER_EXTRA_PADDING;
+}
+OS.gtk_widget_style_get1(handle, OS.focus_line_width.ptr, &w);
+width += 2 * w ;
+auto list = OS.gtk_tree_view_column_get_cell_renderers (column);
+if (list is null) return 0;
+auto temp = list;
+while (temp !is null) {
+auto renderer = OS.g_list_data (temp);
+if (renderer !is null) {
+OS.gtk_cell_renderer_get_size (renderer, handle, null, null, null, &w, null);
+width += w ;
+}
+temp = OS.g_list_next (temp);
+}
+OS.g_list_free (list);
+if (recurse) {
+if (path is null) path = OS.gtk_tree_model_get_path (modelHandle, iter);
+bool expanded = OS.gtk_tree_view_row_expanded (handle, path) !is 0;
+if (expanded) {
+GtkTreeIter childIter;
+bool valid = OS.gtk_tree_model_iter_children (modelHandle, &childIter, iter) !is 0;
+while (valid) {
+width = Math.max (width, calculateWidth (column, &childIter, true));
+valid = OS.gtk_tree_model_iter_next (modelHandle, &childIter) !is 0;
+}
+}
+}
+if (path !is null) OS.gtk_tree_path_free (path);
+return width;
+}
+/**
+* Clears the item at the given zero-relative index in the receiver.
+* The text, icon and other attributes of the item are set to the default
+* value.  If the tree was created with the <code>SWT.VIRTUAL</code> style,
+* these attributes are requested again as needed.
+*
+* @param index the index of the item to clear
+* @param all <code>true</code> if all child items of the indexed item should be
+* cleared recursively, and <code>false</code> otherwise
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see SWT#VIRTUAL
+* @see SWT#SetData
+*
+* @since 3.2
+*/
+public void clear(int index, bool all) {
+checkWidget ();
+clear (null, index, all);
+}
+void clear (GtkTreeIter* parentIter, int index, bool all) {
+GtkTreeIter iter;
+OS.gtk_tree_model_iter_nth_child(modelHandle, &iter, parentIter, index);
+int value;
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&value);
+if (value  !is -1) {
+TreeItem item = items [value ];
+item.clear ();
+}
+if (all) clearAll (all, &iter);
+}
+/**
+* Clears all the items in the receiver. The text, icon and other
+* attributes of the items are set to their default values. If the
+* tree was created with the <code>SWT.VIRTUAL</code> style, these
+* attributes are requested again as needed.
+*
+* @param all <code>true</code> if all child items should be cleared
+* recursively, and <code>false</code> otherwise
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see SWT#VIRTUAL
+* @see SWT#SetData
+*
+* @since 3.2
+*/
+public void clearAll (bool all) {
+checkWidget ();
+clearAll (all, null);
+}
+void clearAll (bool all, GtkTreeIter* parentIter) {
+int length = OS.gtk_tree_model_iter_n_children (modelHandle, parentIter);
+if (length is 0) return;
+GtkTreeIter iter;
+bool valid = cast(bool)OS.gtk_tree_model_iter_children (modelHandle, &iter, parentIter);
+int value;
+while (valid) {
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&value);
+if (value  !is -1) {
+TreeItem item = items [value ];
+item.clear ();
+}
+if (all) clearAll (all, &iter);
+valid = cast(bool)OS.gtk_tree_model_iter_next (modelHandle, &iter);
+}
+}
+public override Point computeSize (int wHint, int hHint, bool changed) {
+checkWidget ();
+if (wHint !is SWT.DEFAULT && wHint < 0) wHint = 0;
+if (hHint !is SWT.DEFAULT && hHint < 0) hHint = 0;
+Point size = computeNativeSize (handle, wHint, hHint, changed);
+Rectangle trim = computeTrim (0, 0, size.x, size.y);
+size.x = trim.width;
+size.y = trim.height;
+return size;
+}
+void copyModel (void* oldModel, int oldStart, void* newModel, int newStart, uint [] types, void* oldParent, void* newParent, int modelLength) {
+GtkTreeIter iter;
+if (OS.gtk_tree_model_iter_children (oldModel, &iter, oldParent))  {
+GtkTreeIter*[] oldItems = new GtkTreeIter*[]( OS.gtk_tree_model_iter_n_children (oldModel, oldParent));
+int oldIndex = 0;
+do {
+GtkTreeIter* newItem = cast(GtkTreeIter*)OS.g_malloc (GtkTreeIter.sizeof);
+if (newItem is null) error (SWT.ERROR_NO_HANDLES);
+OS.gtk_tree_store_append (newModel, newItem, newParent);
+int index;
+OS.gtk_tree_model_get1 (oldModel, &iter, ID_COLUMN, cast(void**)&index);
+TreeItem item = null;
+if (index  !is -1) {
+item = items [index ];
+if (item !is null) {
+auto oldItem = cast(GtkTreeIter*)item.handle;
+oldItems[oldIndex++] = oldItem;
+void* ptr;
+for (int j = 0; j < FIRST_COLUMN; j++) {
+OS.gtk_tree_model_get1 (oldModel, oldItem, j, &ptr);
+OS.gtk_tree_store_set1 (newModel, newItem, j, ptr );
+if (types [j] is OS.G_TYPE_STRING ()) OS.g_free ((ptr ));
+}
+for (int j= 0; j<modelLength - FIRST_COLUMN; j++) {
+OS.gtk_tree_model_get1 (oldModel, oldItem, oldStart + j, &ptr);
+OS.gtk_tree_store_set1 (newModel, newItem, newStart + j, ptr );
+if (types [j] is OS.G_TYPE_STRING ()) OS.g_free ((ptr ));
+}
+}
+} else {
+OS.gtk_tree_store_set1 (newModel, newItem, ID_COLUMN, cast(void*)-1 );
+}
+// recurse through children
+copyModel(oldModel, oldStart, newModel, newStart, types, &iter, newItem, modelLength);
+if (item!is null) {
+item.handle = cast(GtkWidget*)newItem;
+} else {
+OS.g_free (newItem);
+}
+} while (OS.gtk_tree_model_iter_next(oldModel, &iter));
+for (int i = 0; i < oldItems.length; i++) {
+auto oldItem = oldItems [i];
+if (oldItem !is null) {
+OS.gtk_tree_store_remove (oldModel, oldItem);
+OS.g_free (oldItem);
+}
+}
+}
+}
+void createColumn (TreeColumn column, int index) {
+/*
+* Bug in ATK. For some reason, ATK segments fault if
+* the GtkTreeView has a column and does not have items.
+* The fix is to insert the column only when an item is
+* created.
+*/
+int modelIndex = FIRST_COLUMN;
+if (columnCount !is 0) {
+int modelLength = OS.gtk_tree_model_get_n_columns (modelHandle);
+bool [] usedColumns = new bool [modelLength];
+for (int i=0; i<columnCount; i++) {
+int columnIndex = columns [i].modelIndex;
+for (int j = 0; j < CELL_TYPES; j++) {
+usedColumns [columnIndex + j] = true;
+}
+}
+while (modelIndex < modelLength) {
+if (!usedColumns [modelIndex]) break;
+modelIndex++;
+}
+if (modelIndex is modelLength) {
+auto oldModel = modelHandle;
+uint[] types = getColumnTypes (columnCount + 4); // grow by 4 rows at a time
+auto newModel = OS.gtk_tree_store_newv (types.length, types.ptr);
+if (newModel is null) error (SWT.ERROR_NO_HANDLES);
+copyModel (oldModel, FIRST_COLUMN, newModel, FIRST_COLUMN, types, null, null, modelLength);
+OS.gtk_tree_view_set_model (handle, newModel);
+OS.g_object_unref (oldModel);
+modelHandle = newModel;
+}
+}
+auto columnHandle = OS.gtk_tree_view_column_new ();
+if (columnHandle is null) error (SWT.ERROR_NO_HANDLES);
+if (index is 0 && columnCount > 0) {
+TreeColumn checkColumn = columns [0];
+createRenderers (cast(GtkTreeViewColumn *)checkColumn.handle, checkColumn.modelIndex, false, checkColumn.style);
+}
+createRenderers (columnHandle, modelIndex, index is 0, column is null ? 0 : column.style);
+/*
+* Use GTK_TREE_VIEW_COLUMN_GROW_ONLY on GTK versions < 2.3.2
+* because fixed_height_mode is not supported.
+*/
+bool useVirtual = (style & SWT.VIRTUAL) !is 0 && OS.GTK_VERSION >= OS.buildVERSION (2, 3, 2);
+if (!useVirtual && columnCount is 0) {
+OS.gtk_tree_view_column_set_sizing (columnHandle, OS.GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+} else {
+OS.gtk_tree_view_column_set_sizing (columnHandle, OS.GTK_TREE_VIEW_COLUMN_FIXED);
+if (columnCount !is 0) OS.gtk_tree_view_column_set_visible (columnHandle, false);
+}
+OS.gtk_tree_view_column_set_resizable (columnHandle, true);
+OS.gtk_tree_view_column_set_clickable (columnHandle, true);
+OS.gtk_tree_view_column_set_min_width (columnHandle, 0);
+OS.gtk_tree_view_insert_column (handle, columnHandle, index);
+if (column !is null) {
+column.handle = cast(GtkWidget*)columnHandle;
+column.modelIndex = modelIndex;
+}
+/* Disable searching when using VIRTUAL */
+if ((style & SWT.VIRTUAL) !is 0) {
+/*
+* Bug in GTK. Until GTK 2.6.5, calling gtk_tree_view_set_enable_search(FALSE)
+* would prevent the user from being able to type in text to search the tree.
+* After 2.6.5, GTK introduced Ctrl+F as being the key binding for interactive
+* search. This meant that even if FALSE was passed to enable_search, the user
+* can still bring up the search pop up using the keybinding. GTK also introduced
+* the notion of passing a -1 to gtk_set_search_column to disable searching
+* (including the search key binding).  The fix is to use the right calls
+* for the right version.
+*/
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 6, 5)) {
+OS.gtk_tree_view_set_search_column (handle, -1);
+} else {
+OS.gtk_tree_view_set_enable_search (handle, false);
+}
+} else {
+/* Set the search column whenever the model changes */
+int firstColumn = columnCount is 0 ? FIRST_COLUMN : columns [0].modelIndex;
+OS.gtk_tree_view_set_search_column (handle, firstColumn + CELL_TEXT);
+}
+}
+override void createHandle (int index) {
+state |= HANDLE;
+fixedHandle = cast(GtkWidget*)OS.g_object_new (display.gtk_fixed_get_type (), null);
+if (fixedHandle is null) error (SWT.ERROR_NO_HANDLES);
+OS.gtk_fixed_set_has_window (fixedHandle, true);
+scrolledHandle = cast(GtkWidget*)OS.gtk_scrolled_window_new (null, null);
+if (scrolledHandle is null) error (SWT.ERROR_NO_HANDLES);
+uint[] types = getColumnTypes (1);
+modelHandle = cast(GtkTreeStore*)OS.gtk_tree_store_newv (types.length, types.ptr);
+if (modelHandle is null) error (SWT.ERROR_NO_HANDLES);
+handle = cast(GtkWidget*)OS.gtk_tree_view_new_with_model (modelHandle);
+if (handle is null) error (SWT.ERROR_NO_HANDLES);
+if ((style & SWT.CHECK) !is 0) {
+checkRenderer = cast(GtkCellRenderer*)OS.gtk_cell_renderer_toggle_new ();
+if (checkRenderer is null) error (SWT.ERROR_NO_HANDLES);
+OS.g_object_ref (checkRenderer);
+}
+createColumn (null, 0);
+OS.gtk_container_add (fixedHandle, scrolledHandle);
+OS.gtk_container_add (scrolledHandle, handle);
+int mode = (style & SWT.MULTI) !is 0 ? OS.GTK_SELECTION_MULTIPLE : OS.GTK_SELECTION_BROWSE;
+auto selectionHandle = OS.gtk_tree_view_get_selection (handle);
+OS.gtk_tree_selection_set_mode (selectionHandle, mode);
+OS.gtk_tree_view_set_headers_visible (handle, false);
+int hsp = (style & SWT.H_SCROLL) !is 0 ? OS.GTK_POLICY_AUTOMATIC : OS.GTK_POLICY_NEVER;
+int vsp = (style & SWT.V_SCROLL) !is 0 ? OS.GTK_POLICY_AUTOMATIC : OS.GTK_POLICY_NEVER;
+OS.gtk_scrolled_window_set_policy (scrolledHandle, hsp, vsp);
+if ((style & SWT.BORDER) !is 0) OS.gtk_scrolled_window_set_shadow_type (scrolledHandle, OS.GTK_SHADOW_ETCHED_IN);
+/* Disable searching when using VIRTUAL */
+if ((style & SWT.VIRTUAL) !is 0) {
+/* The fixed_height_mode property only exists in GTK 2.3.2 and greater */
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 3, 2)) {
+OS.g_object_set1 (handle, OS.fixed_height_mode.ptr, true);
+}
+/*
+* Bug in GTK. Until GTK 2.6.5, calling gtk_tree_view_set_enable_search(FALSE)
+* would prevent the user from being able to type in text to search the tree.
+* After 2.6.5, GTK introduced Ctrl+F as being the key binding for interactive
+* search. This meant that even if FALSE was passed to enable_search, the user
+* can still bring up the search pop up using the keybinding. GTK also introduced
+* the notion of passing a -1 to gtk_set_search_column to disable searching
+* (including the search key binding).  The fix is to use the right calls
+* for the right version.
+*/
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 6, 5)) {
+OS.gtk_tree_view_set_search_column (handle, -1);
+} else {
+OS.gtk_tree_view_set_enable_search (handle, false);
+};
+}
+}
+void createItem (TreeColumn column, int index) {
+if (!(0 <= index && index <= columnCount)) error (SWT.ERROR_INVALID_RANGE);
+if (index is 0) {
+// first column must be left aligned
+column.style &= ~(SWT.LEFT | SWT.RIGHT | SWT.CENTER);
+column.style |= SWT.LEFT;
+}
+if (columnCount is 0) {
+column.handle = cast(GtkWidget*)OS.gtk_tree_view_get_column (handle, 0);
+OS.gtk_tree_view_column_set_sizing (column.handle, OS.GTK_TREE_VIEW_COLUMN_FIXED);
+OS.gtk_tree_view_column_set_visible (column.handle, false);
+column.modelIndex = FIRST_COLUMN;
+createRenderers (cast(GtkTreeViewColumn *)column.handle, column.modelIndex, true, column.style);
+column.customDraw = firstCustomDraw;
+firstCustomDraw = false;
+} else {
+createColumn (column, index);
+}
+auto boxHandle = OS.gtk_hbox_new (false, 3);
+if (boxHandle is null) error (SWT.ERROR_NO_HANDLES);
+auto labelHandle = OS.gtk_label_new_with_mnemonic (null);
+if (labelHandle is null) error (SWT.ERROR_NO_HANDLES);
+auto imageHandle = OS.gtk_image_new ();
+if (imageHandle is null) error (SWT.ERROR_NO_HANDLES);
+OS.gtk_container_add (boxHandle, imageHandle);
+OS.gtk_container_add (boxHandle, labelHandle);
+OS.gtk_widget_show (boxHandle);
+OS.gtk_widget_show (labelHandle);
+column.labelHandle = labelHandle;
+column.imageHandle = imageHandle;
+OS.gtk_tree_view_column_set_widget (column.handle, boxHandle);
+auto widget = OS.gtk_widget_get_parent (boxHandle);
+while (widget !is handle) {
+if (OS.GTK_IS_BUTTON (widget)) {
+column.buttonHandle = widget;
+break;
+}
+widget = OS.gtk_widget_get_parent (widget);
+}
+if (columnCount is columns.length) {
+TreeColumn [] newColumns = new TreeColumn [columns.length + 4];
+System.arraycopy (columns, 0, newColumns, 0, columns.length);
+columns = newColumns;
+}
+System.arraycopy (columns, index, columns, index + 1, columnCount++ - index);
+columns [index] = column;
+if ((state & FONT) !is 0) {
+column.setFontDescription (getFontDescription ());
+}
+if (columnCount >= 1) {
+for (int i=0; i<items.length; i++) {
+TreeItem item = items [i];
+if (item !is null) {
+Font [] cellFont = item.cellFont;
+if (cellFont !is null) {
+Font [] temp = new Font [columnCount];
+System.arraycopy (cellFont, 0, temp, 0, index);
+System.arraycopy (cellFont, index, temp, index+1, columnCount-index-1);
+item.cellFont = temp;
+}
+}
+}
+}
+}
+void createItem (TreeItem item, GtkTreeIter* parentIter, int index) {
+int count = OS.gtk_tree_model_iter_n_children (modelHandle, parentIter);
+if (index is -1) index = count;
+if (!(0 <= index && index <= count)) error (SWT.ERROR_INVALID_RANGE);
+item.handle = cast(GtkWidget*)OS.g_malloc (GtkTreeIter.sizeof);
+if (item.handle is null) error(SWT.ERROR_NO_HANDLES);
+/*
+* Feature in GTK.  It is much faster to append to a tree store
+* than to insert at the end using gtk_tree_store_insert().
+*/
+if (index is count) {
+OS.gtk_tree_store_append (modelHandle, item.handle, parentIter);
+} else {
+OS.gtk_tree_store_insert (modelHandle, item.handle, parentIter, index);
+}
+int id = getId (cast(GtkTreeIter*) item.handle, false);
+items [id] = item;
+modelChanged = true;
+}
+void createRenderers (GtkTreeViewColumn* columnHandle, int modelIndex, bool check, int columnStyle) {
+OS.gtk_tree_view_column_clear (columnHandle);
+if ((style & SWT.CHECK) !is 0 && check) {
+OS.gtk_tree_view_column_pack_start (columnHandle, checkRenderer, false);
+OS.gtk_tree_view_column_add_attribute (columnHandle, checkRenderer, OS.active.ptr, CHECKED_COLUMN);
+/*
+* Feature in GTK. The inconsistent property only exists in GTK 2.2.x.
+*/
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 2, 0)) {
+OS.gtk_tree_view_column_add_attribute (columnHandle, checkRenderer, OS.inconsistent.ptr, GRAYED_COLUMN);
+}
+/*
+* Bug in GTK. GTK renders the background on top of the checkbox.
+* This only happens in version 2.2.1 and earlier. The fix is not to set the background.
+*/
+if (OS.GTK_VERSION > OS.buildVERSION (2, 2, 1)) {
+if (!ownerDraw) OS.gtk_tree_view_column_add_attribute (columnHandle, checkRenderer, OS.cell_background_gdk.ptr, BACKGROUND_COLUMN);
+}
+if (ownerDraw) {
+display.doCellDataProc( handle, cast(GtkTreeViewColumn*)columnHandle, cast(GtkCellRenderer*)checkRenderer );
+OS.g_object_set_qdata (cast(GObject*)checkRenderer, Display.SWT_OBJECT_INDEX1, columnHandle);
+}
+}
+auto pixbufRenderer = ownerDraw ? cast(GtkCellRenderer*)OS.g_object_new (display.gtk_cell_renderer_pixbuf_get_type (), null) : OS.gtk_cell_renderer_pixbuf_new ();
+if (pixbufRenderer is null) error (SWT.ERROR_NO_HANDLES);
+auto textRenderer = ownerDraw ? cast(GtkCellRenderer*)OS.g_object_new (display.gtk_cell_renderer_text_get_type (), null) : OS.gtk_cell_renderer_text_new ();
+if (textRenderer is null) error (SWT.ERROR_NO_HANDLES);
+if (ownerDraw) {
+OS.g_object_set_qdata (cast(GObject*)pixbufRenderer, Display.SWT_OBJECT_INDEX1, columnHandle);
+OS.g_object_set_qdata (cast(GObject*)textRenderer, Display.SWT_OBJECT_INDEX1, columnHandle);
+}
+/*
+* Feature in GTK.  When a tree view column contains only one activatable
+* cell renderer such as a toggle renderer, mouse clicks anywhere in a cell
+* activate that renderer. The workaround is to set a second  cell renderer
+* to be activatable.
+*/
+if ((style & SWT.CHECK) !is 0 && check) {
+OS.g_object_set1 (pixbufRenderer, OS.mode.ptr, OS.GTK_CELL_RENDERER_MODE_ACTIVATABLE);
+}
+/* Set alignment */
+if ((columnStyle & SWT.RIGHT) !is 0) {
+OS.g_object_set1_float(textRenderer, OS.xalign.ptr, 1.0f);
+OS.gtk_tree_view_column_pack_end (columnHandle, textRenderer, true);
+OS.gtk_tree_view_column_pack_end (columnHandle, pixbufRenderer, false);
+OS.gtk_tree_view_column_set_alignment (columnHandle, 1f);
+} else if ((columnStyle & SWT.CENTER) !is 0) {
+OS.g_object_set1_float(textRenderer, OS.xalign.ptr, 0.5f);
+OS.gtk_tree_view_column_pack_start (columnHandle, pixbufRenderer, false);
+OS.gtk_tree_view_column_pack_end (columnHandle, textRenderer, true);
+OS.gtk_tree_view_column_set_alignment (columnHandle, 0.5f);
+} else {
+OS.gtk_tree_view_column_pack_start (columnHandle, pixbufRenderer, false);
+OS.gtk_tree_view_column_pack_start (columnHandle, textRenderer, true);
+OS.gtk_tree_view_column_set_alignment (columnHandle, 0f);
+}
+/* Add attributes */
+OS.gtk_tree_view_column_add_attribute (columnHandle, pixbufRenderer, OS.pixbuf.ptr, modelIndex + CELL_PIXBUF);
+/*
+* Bug on GTK. Gtk renders the background on top of the pixbuf.
+* This only happens in version 2.2.1 and earlier. The fix is not to set the background.
+*/
+if (OS.GTK_VERSION > OS.buildVERSION (2, 2, 1)) {
+if (!ownerDraw) {
+OS.gtk_tree_view_column_add_attribute (columnHandle, pixbufRenderer, OS.cell_background_gdk.ptr, BACKGROUND_COLUMN);
+OS.gtk_tree_view_column_add_attribute (columnHandle, textRenderer, OS.cell_background_gdk.ptr, BACKGROUND_COLUMN);
+}
+}
+OS.gtk_tree_view_column_add_attribute (columnHandle, textRenderer, OS.text.ptr, modelIndex + CELL_TEXT);
+OS.gtk_tree_view_column_add_attribute (columnHandle, textRenderer, OS.foreground_gdk.ptr, FOREGROUND_COLUMN);
+OS.gtk_tree_view_column_add_attribute (columnHandle, textRenderer, OS.font_desc.ptr, FONT_COLUMN);
+bool customDraw = firstCustomDraw;
+if (columnCount !is 0) {
+for (int i=0; i<columnCount; i++) {
+if (columns [i].handle is cast(GtkWidget*)columnHandle) {
+customDraw = columns [i].customDraw;
+break;
+}
+}
+}
+if ((style & SWT.VIRTUAL) !is 0 || customDraw || ownerDraw) {
+display.doCellDataProc( handle, cast(GtkTreeViewColumn*)columnHandle, cast(GtkCellRenderer*)textRenderer );
+display.doCellDataProc( handle, cast(GtkTreeViewColumn*)columnHandle, cast(GtkCellRenderer*)pixbufRenderer );
+}
+}
+void createWidget (int index) {
+super.createWidget (index);
+items = new TreeItem [4];
+columns = new TreeColumn [4];
+columnCount = 0;
+}
+GdkColor* defaultBackground () {
+return display.COLOR_LIST_BACKGROUND;
+}
+GdkColor* defaultForeground () {
+return display.COLOR_LIST_FOREGROUND;
+}
+override void deregister () {
+super.deregister ();
+display.removeWidget (cast(GtkWidget*)OS.gtk_tree_view_get_selection (handle));
+if (checkRenderer !is null) display.removeWidget (cast(GtkWidget*)checkRenderer);
+}
+/**
+* Deselects an item in the receiver.  If the item was already
+* deselected, it remains deselected.
+*
+* @param item the item to be deselected
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.4
+*/
+public void deselect (TreeItem item) {
+checkWidget ();
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (item.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
+bool fixColumn = showFirstColumn ();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_selection_unselect_iter (selection, item.handle);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+if (fixColumn) hideFirstColumn ();
+}
+/**
+* Deselects all selected items in the receiver.
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public void deselectAll() {
+checkWidget();
+bool fixColumn = showFirstColumn ();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_selection_unselect_all (selection);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+if (fixColumn) hideFirstColumn ();
+}
+void destroyItem (TreeColumn column) {
+int index = 0;
+while (index < columnCount) {
+if (columns [index] is column) break;
+index++;
+}
+if (index is columnCount) return;
+auto columnHandle = column.handle;
+if (columnCount is 1) {
+firstCustomDraw = column.customDraw;
+}
+System.arraycopy (columns, index + 1, columns, index, --columnCount - index);
+columns [columnCount] = null;
+OS.gtk_tree_view_remove_column (handle, columnHandle);
+if (columnCount is 0) {
+auto oldModel = modelHandle;
+uint[] types = getColumnTypes (1);
+auto newModel = OS.gtk_tree_store_newv (types.length, types.ptr);
+if (newModel is null) error (SWT.ERROR_NO_HANDLES);
+copyModel(oldModel, column.modelIndex, newModel, FIRST_COLUMN, types, null, null, FIRST_COLUMN + CELL_TYPES);
+OS.gtk_tree_view_set_model (handle, newModel);
+OS.g_object_unref (oldModel);
+modelHandle = newModel;
+createColumn (null, 0);
+} else {
+for (int i=0; i<items.length; i++) {
+TreeItem item = items [i];
+if (item !is null) {
+auto iter = cast(GtkTreeIter*)item.handle;
+int modelIndex = column.modelIndex;
+OS.gtk_tree_store_set1 (modelHandle, iter, modelIndex + CELL_PIXBUF, null);
+OS.gtk_tree_store_set1 (modelHandle, iter, modelIndex + CELL_TEXT, null);
+OS.gtk_tree_store_set1 (modelHandle, iter, modelIndex + CELL_FOREGROUND, null);
+OS.gtk_tree_store_set1 (modelHandle, iter, modelIndex + CELL_BACKGROUND, null);
+OS.gtk_tree_store_set1 (modelHandle, iter, modelIndex + CELL_FONT, null);
+Font [] cellFont = item.cellFont;
+if (cellFont !is null) {
+if (columnCount is 0) {
+item.cellFont = null;
+} else {
+Font [] temp = new Font [columnCount];
+System.arraycopy (cellFont, 0, temp, 0, index);
+System.arraycopy (cellFont, index + 1, temp, index, columnCount - index);
+item.cellFont = temp;
+}
+}
+}
+}
+if (index is 0) {
+// first column must be left aligned and must show check box
+TreeColumn firstColumn = columns [0];
+firstColumn.style &= ~(SWT.LEFT | SWT.RIGHT | SWT.CENTER);
+firstColumn.style |= SWT.LEFT;
+createRenderers (cast(GtkTreeViewColumn*)firstColumn.handle, firstColumn.modelIndex, true, firstColumn.style);
+}
+}
+/* Disable searching when using VIRTUAL */
+if ((style & SWT.VIRTUAL) !is 0) {
+/*
+* Bug in GTK. Until GTK 2.6.5, calling gtk_tree_view_set_enable_search(FALSE)
+* would prevent the user from being able to type in text to search the tree.
+* After 2.6.5, GTK introduced Ctrl+F as being the key binding for interactive
+* search. This meant that even if FALSE was passed to enable_search, the user
+* can still bring up the search pop up using the keybinding. GTK also introduced
+* the notion of passing a -1 to gtk_set_search_column to disable searching
+* (including the search key binding).  The fix is to use the right calls
+* for the right version.
+*/
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 6, 5)) {
+OS.gtk_tree_view_set_search_column (handle, -1);
+} else {
+OS.gtk_tree_view_set_enable_search (handle, false);
+}
+} else {
+/* Set the search column whenever the model changes */
+int firstColumn = columnCount is 0 ? FIRST_COLUMN : columns [0].modelIndex;
+OS.gtk_tree_view_set_search_column (handle, firstColumn + CELL_TEXT);
+}
+}
+void destroyItem (TreeItem item) {
+/*
+* Bug in GTK.  GTK segment faults when a root tree item
+* is destroyed when the tree is expanded and the last leaf of
+* the root is selected.  This only happens in versions earlier
+* than 2.0.6.  The fix is to collapse the tree item being destroyed
+* when it is a root, before it is destroyed.
+*/
+if (OS.GTK_VERSION < OS.buildVERSION (2, 0, 6)) {
+int length = OS.gtk_tree_model_iter_n_children (modelHandle, null);
+if (length > 0) {
+GtkTreeIter iter;
+bool valid = cast(bool)OS.gtk_tree_model_iter_children (modelHandle, &iter, null);
+while (valid) {
+//PORTING_TODO: is this condition reasonable?
+if (item.handle is cast(GtkWidget*)&iter) {
+item.setExpanded (false);
+break;
+}
+valid = cast(bool)OS.gtk_tree_model_iter_next (modelHandle, &iter);
+}
+}
+}
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_store_remove (modelHandle, item.handle);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+modelChanged = true;
+}
+override bool dragDetect (int x, int y, bool filter, bool * consume) {
+bool selected = false;
+if (filter) {
+void* path;
+if (OS.gtk_tree_view_get_path_at_pos (handle, x, y, &path, null, null, null)) {
+if (path  !is null) {
+auto selection = OS.gtk_tree_view_get_selection (handle);
+if (OS.gtk_tree_selection_path_is_selected (selection, path )) selected = true;
+OS.gtk_tree_path_free (path );
+}
+} else {
+return false;
+}
+}
+bool dragDetect = super.dragDetect (x, y, filter, consume);
+if (dragDetect && selected && consume !is null) consume [0] = true;
+return dragDetect;
+}
+override GdkDrawable* eventWindow () {
+return paintWindow ();
+}
+override void fixChildren (Shell newShell, Shell oldShell, Decorations newDecorations, Decorations oldDecorations, Menu [] menus) {
+super.fixChildren (newShell, oldShell, newDecorations, oldDecorations, menus);
+for (int i=0; i<columnCount; i++) {
+TreeColumn column = columns [i];
+if (column.toolTipText !is null) {
+column.setToolTipText(oldShell, null);
+column.setToolTipText(newShell, column.toolTipText);
+}
+}
+}
+override GdkColor* getBackgroundColor () {
+return getBaseColor ();
+}
+public override Rectangle getClientArea () {
+checkWidget ();
+forceResize ();
+OS.gtk_widget_realize (handle);
+auto fixedWindow = OS.GTK_WIDGET_WINDOW (fixedHandle);
+auto binWindow = OS.gtk_tree_view_get_bin_window (handle);
+int binX, binY;
+OS.gdk_window_get_origin (binWindow, &binX, &binY);
+int fixedX, fixedY;
+OS.gdk_window_get_origin (fixedWindow, &fixedX, &fixedY);
+auto clientHandle = clientHandle ();
+int width = (state & ZERO_WIDTH) !is 0 ? 0 : OS.GTK_WIDGET_WIDTH (clientHandle);
+int height = (state & ZERO_HEIGHT) !is 0 ? 0 : OS.GTK_WIDGET_HEIGHT (clientHandle);
+return new Rectangle (fixedX  - binX , fixedY  - binY , width, height);
+}
+int getClientWidth () {
+int w, h;
+OS.gtk_widget_realize (handle);
+OS.gdk_drawable_get_size(OS.gtk_tree_view_get_bin_window(handle), &w, &h);
+return w;
+}
+/**
+* Returns the column at the given, zero-relative index in the
+* receiver. Throws an exception if the index is out of range.
+* Columns are returned in the order that they were created.
+* If no <code>TreeColumn</code>s were created by the programmer,
+* this method will throw <code>ERROR_INVALID_RANGE</code> despite
+* the fact that a single column of data may be visible in the tree.
+* This occurs when the programmer uses the tree like a list, adding
+* items but never creating a column.
+*
+* @param index the index of the column to return
+* @return the column at the given index
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#getColumnOrder()
+* @see Tree#setColumnOrder(int[])
+* @see TreeColumn#getMoveable()
+* @see TreeColumn#setMoveable(bool)
+* @see SWT#Move
+*
+* @since 3.1
+*/
+public TreeColumn getColumn (int index) {
+checkWidget();
+if (!(0 <= index && index < columnCount)) error (SWT.ERROR_INVALID_RANGE);
+return columns [index];
+}
+/**
+* Returns the number of columns contained in the receiver.
+* If no <code>TreeColumn</code>s were created by the programmer,
+* this value is zero, despite the fact that visually, one column
+* of items may be visible. This occurs when the programmer uses
+* the tree like a list, adding items but never creating a column.
+*
+* @return the number of columns
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public int getColumnCount () {
+checkWidget();
+return columnCount;
+}
+/**
+* Returns an array of zero-relative integers that map
+* the creation order of the receiver's items to the
+* order in which they are currently being displayed.
+* <p>
+* Specifically, the indices of the returned array represent
+* the current visual order of the items, and the contents
+* of the array represent the creation order of the items.
+* </p><p>
+* Note: This is not the actual structure used by the receiver
+* to maintain its list of items, so modifying the array will
+* not affect the receiver.
+* </p>
+*
+* @return the current visual order of the receiver's items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#setColumnOrder(int[])
+* @see TreeColumn#getMoveable()
+* @see TreeColumn#setMoveable(bool)
+* @see SWT#Move
+*
+* @since 3.2
+*/
+public int [] getColumnOrder () {
+checkWidget ();
+if (columnCount is 0) return null;
+auto list = OS.gtk_tree_view_get_columns (handle);
+if (list is null) return null;
+int  i = 0, count = OS.g_list_length (list);
+int [] order = new int [count];
+auto temp = list;
+while (temp !is null) {
+auto column = OS.g_list_data (temp);
+if (column !is null) {
+for (int j=0; j<columnCount; j++) {
+if (columns [j].handle is column) {
+order [i++] = j;
+break;
+}
+}
+}
+temp = OS.g_list_next (temp);
+}
+OS.g_list_free (list);
+return order;
+}
+uint[] getColumnTypes (int columnCount) {
+uint[] types = new uint [FIRST_COLUMN + (columnCount * CELL_TYPES)];
+// per row data
+types [ID_COLUMN] = OS.G_TYPE_INT ();
+types [CHECKED_COLUMN] = OS.G_TYPE_BOOLEAN ();
+types [GRAYED_COLUMN] = OS.G_TYPE_BOOLEAN ();
+types [FOREGROUND_COLUMN] = OS.GDK_TYPE_COLOR ();
+types [BACKGROUND_COLUMN] = OS.GDK_TYPE_COLOR ();
+types [FONT_COLUMN] = OS.PANGO_TYPE_FONT_DESCRIPTION ();
+// per cell data
+for (int i=FIRST_COLUMN; i<types.length; i+=CELL_TYPES) {
+types [i + CELL_PIXBUF] = OS.GDK_TYPE_PIXBUF ();
+types [i + CELL_TEXT] = OS.G_TYPE_STRING ();
+types [i + CELL_FOREGROUND] = OS.GDK_TYPE_COLOR ();
+types [i + CELL_BACKGROUND] = OS.GDK_TYPE_COLOR ();
+types [i + CELL_FONT] = OS.PANGO_TYPE_FONT_DESCRIPTION ();
+}
+return types;
+}
+/**
+* Returns an array of <code>TreeColumn</code>s which are the
+* columns in the receiver. Columns are returned in the order
+* that they were created.  If no <code>TreeColumn</code>s were
+* created by the programmer, the array is empty, despite the fact
+* that visually, one column of items may be visible. This occurs
+* when the programmer uses the tree like a list, adding items but
+* never creating a column.
+* <p>
+* Note: This is not the actual structure used by the receiver
+* to maintain its list of items, so modifying the array will
+* not affect the receiver.
+* </p>
+*
+* @return the items in the receiver
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#getColumnOrder()
+* @see Tree#setColumnOrder(int[])
+* @see TreeColumn#getMoveable()
+* @see TreeColumn#setMoveable(bool)
+* @see SWT#Move
+*
+* @since 3.1
+*/
+public TreeColumn [] getColumns () {
+checkWidget();
+TreeColumn [] result = new TreeColumn [columnCount];
+System.arraycopy (columns, 0, result, 0, columnCount);
+return result;
+}
+TreeItem getFocusItem () {
+GtkTreePath* path;
+OS.gtk_tree_view_get_cursor (handle, &path, null);
+if (path  is null) return null;
+TreeItem item = null;
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, path)) {
+int index;
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&index);
+if (index  !is -1) item = items [index ]; //TODO should we be creating this item when index is -1?
+}
+OS.gtk_tree_path_free (path );
+return item;
+}
+override GdkColor* getForegroundColor () {
+return getTextColor ();
+}
+/**
+* Returns the width in pixels of a grid line.
+*
+* @return the width of a grid line in pixels
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public int getGridLineWidth () {
+checkWidget();
+return 0;
+}
+/**
+* Returns the height of the receiver's header
+*
+* @return the height of the header or zero if the header is not visible
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public int getHeaderHeight () {
+checkWidget ();
+if (!OS.gtk_tree_view_get_headers_visible (handle)) return 0;
+if (columnCount > 0) {
+GtkRequisition requisition;
+int height = 0;
+for (int i=0; i<columnCount; i++) {
+auto buttonHandle = columns [i].buttonHandle;
+if (buttonHandle !is null) {
+OS.gtk_widget_size_request (buttonHandle, &requisition);
+height = Math.max (height, requisition.height);
+}
+}
+return height;
+}
+OS.gtk_widget_realize (handle);
+auto fixedWindow = OS.GTK_WIDGET_WINDOW (fixedHandle);
+auto binWindow = OS.gtk_tree_view_get_bin_window (handle);
+int binY ;
+OS.gdk_window_get_origin (binWindow, null, &binY);
+int fixedY;
+OS.gdk_window_get_origin (fixedWindow, null, &fixedY);
+return binY  - fixedY ;
+}
+/**
+* Returns <code>true</code> if the receiver's header is visible,
+* and <code>false</code> otherwise.
+* <p>
+* If one of the receiver's ancestors is not visible or some
+* other condition makes the receiver not visible, this method
+* may still indicate that it is considered visible even though
+* it may not actually be showing.
+* </p>
+*
+* @return the receiver's header's visibility state
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public bool getHeaderVisible () {
+checkWidget();
+return cast(bool)OS.gtk_tree_view_get_headers_visible (handle);
+}
+/**
+* Returns the item at the given, zero-relative index in the
+* receiver. Throws an exception if the index is out of range.
+*
+* @param index the index of the item to return
+* @return the item at the given index
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public TreeItem getItem (int index) {
+checkWidget();
+if (!(0 <= index && index < OS.gtk_tree_model_iter_n_children (modelHandle, null)))  {
+error (SWT.ERROR_INVALID_RANGE);
+}
+return _getItem (null, index);
+}
+/**
+* Returns the item at the given point in the receiver
+* or null if no such item exists. The point is in the
+* coordinate system of the receiver.
+* <p>
+* The item that is returned represents an item that could be selected by the user.
+* For example, if selection only occurs in items in the first column, then null is
+* returned if the point is outside of the item.
+* Note that the SWT.FULL_SELECTION style hint, which specifies the selection policy,
+* determines the extent of the selection.
+* </p>
+*
+* @param point the point used to locate the item
+* @return the item at the given point, or null if the point is not in a selectable item
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the point is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public TreeItem getItem (Point point) {
+checkWidget ();
+if (point is null) error (SWT.ERROR_NULL_ARGUMENT);
+void* path;
+OS.gtk_widget_realize (handle);
+GtkTreeViewColumn* columnHandle;
+if (!OS.gtk_tree_view_get_path_at_pos (handle, point.x, point.y, &path, &columnHandle, null, null)) return null;
+if (path  is null) return null;
+TreeItem item = null;
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, path )) {
+bool overExpander = false;
+if (OS.gtk_tree_view_get_expander_column (handle) is columnHandle ) {
+int buffer;
+GdkRectangle rect;
+OS.gtk_tree_view_get_cell_area (handle, path, columnHandle, &rect);
+if (OS.GTK_VERSION < OS.buildVERSION (2, 8, 18)) {
+OS.gtk_widget_style_get1 (handle, OS.expander_size.ptr, &buffer);
+int expanderSize = buffer  + TreeItem.EXPANDER_EXTRA_PADDING;
+overExpander = point.x < rect.x + expanderSize;
+} else {
+overExpander = point.x < rect.x;
+}
+}
+if (!overExpander) {
+item = _getItem (&iter);
+}
+}
+OS.gtk_tree_path_free (path );
+return item;
+}
+/**
+* Returns the number of items contained in the receiver
+* that are direct item children of the receiver.  The
+* number that is returned is the number of roots in the
+* tree.
+*
+* @return the number of items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public int getItemCount () {
+checkWidget ();
+return OS.gtk_tree_model_iter_n_children (modelHandle, null);
+}
+/**
+* Returns the height of the area which would be used to
+* display <em>one</em> of the items in the tree.
+*
+* @return the height of one item
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public int getItemHeight () {
+checkWidget ();
+int itemCount = OS.gtk_tree_model_iter_n_children (modelHandle, null);
+if (itemCount is 0) {
+auto column = OS.gtk_tree_view_get_column (handle, 0);
+int w, h;
+ignoreSize = true;
+OS.gtk_tree_view_column_cell_get_size (column, null, null, null, &w, &h);
+ignoreSize = false;
+return h ;
+} else {
+int height = 0;
+GtkTreeIter iter;
+OS.gtk_tree_model_get_iter_first (modelHandle, &iter);
+int columnCount = Math.max (1, this.columnCount);
+for (int i=0; i<columnCount; i++) {
+auto column = OS.gtk_tree_view_get_column (handle, i);
+OS.gtk_tree_view_column_cell_set_cell_data (column, modelHandle, &iter, false, false);
+int w, h;
+OS.gtk_tree_view_column_cell_get_size (column, null, null, null, &w, &h);
+height = Math.max (height, h );
+}
+return height;
+}
+}
+/**
+* Returns a (possibly empty) array of items contained in the
+* receiver that are direct item children of the receiver.  These
+* are the roots of the tree.
+* <p>
+* Note: This is not the actual structure used by the receiver
+* to maintain its list of items, so modifying the array will
+* not affect the receiver.
+* </p>
+*
+* @return the items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public TreeItem [] getItems () {
+checkWidget();
+return getItems (null);
+}
+TreeItem [] getItems (GtkTreeIter* parent) {
+int length = OS.gtk_tree_model_iter_n_children (modelHandle, parent);
+TreeItem[] result = new TreeItem [length];
+if (length is 0) return result;
+if ((style & SWT.VIRTUAL) !is 0) {
+for (int i=0; i<length; i++) {
+result [i] = _getItem (parent, i);
+}
+} else {
+int i = 0;
+int index;
+GtkTreeIter iter;
+bool valid = cast(bool)OS.gtk_tree_model_iter_children (modelHandle, &iter, parent);
+while (valid) {
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&index);
+result [i++] = items [index ];
+valid = cast(bool)OS.gtk_tree_model_iter_next (modelHandle, &iter);
+}
+}
+return result;
+}
+/**
+* Returns <code>true</code> if the receiver's lines are visible,
+* and <code>false</code> otherwise.
+* <p>
+* If one of the receiver's ancestors is not visible or some
+* other condition makes the receiver not visible, this method
+* may still indicate that it is considered visible even though
+* it may not actually be showing.
+* </p>
+*
+* @return the visibility state of the lines
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public bool getLinesVisible() {
+checkWidget();
+return cast(bool)OS.gtk_tree_view_get_rules_hint (handle);
+}
+/**
+* Returns the receiver's parent item, which must be a
+* <code>TreeItem</code> or null when the receiver is a
+* root.
+*
+* @return the receiver's parent item
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public TreeItem getParentItem () {
+checkWidget ();
+return null;
+}
+GtkCellRendererPixbuf* getPixbufRenderer (GtkTreeViewColumn* column) {
+auto list = OS.gtk_tree_view_column_get_cell_renderers (column);
+if (list is null) return null;
+int count = OS.g_list_length (list);
+GtkCellRendererPixbuf* pixbufRenderer;
+int i = 0;
+while (i < count) {
+auto renderer = OS.g_list_nth_data (list, i);
+if (OS.GTK_IS_CELL_RENDERER_PIXBUF (renderer)) {
+pixbufRenderer = cast(GtkCellRendererPixbuf*)renderer;
+break;
+}
+i++;
+}
+OS.g_list_free (list);
+return pixbufRenderer;
+}
+/**
+* Returns an array of <code>TreeItem</code>s that are currently
+* selected in the receiver. The order of the items is unspecified.
+* An empty array indicates that no items are selected.
+* <p>
+* Note: This is not the actual structure used by the receiver
+* to maintain its selection, so modifying the array will
+* not affect the receiver.
+* </p>
+* @return an array representing the selection
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public TreeItem[] getSelection () {
+checkWidget();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+if (OS.GTK_VERSION < OS.buildVERSION (2, 2, 0)) {
+display.treeSelectionLength  = 0;
+display.treeSelection = new int [items.length];
+display.doTreeSelectionProcConnect( &treeSelectionCallbackData, handle, selection );
+TreeItem [] result = new TreeItem [display.treeSelectionLength];
+for (int i=0; i<result.length; i++) result [i] = items [display.treeSelection [i]];
+return result;
+}
+/*
+* Bug in GTK.  gtk_tree_selection_get_selected_rows() segmentation faults
+* in versions smaller than 2.2.4 if the model is NULL.  The fix is
+* to give a valid pointer instead.
+*/
+int dummy;
+void* model = OS.GTK_VERSION < OS.buildVERSION (2, 2, 4) ? &dummy : null;
+auto list = OS.gtk_tree_selection_get_selected_rows (selection, &model);
+if (list !is null) {
+int count = OS.g_list_length (list);
+TreeItem [] treeSelection = new TreeItem [count];
+int length_ = 0;
+for (int i=0; i<count; i++) {
+auto data = OS.g_list_nth_data (list, i);
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, data)) {
+treeSelection [length_] = _getItem (&iter);
+length_++;
+}
+}
+OS.g_list_free (list);
+if (length_ < count) {
+TreeItem [] temp = new TreeItem [length_];
+System.arraycopy(treeSelection, 0, temp, 0, length_);
+treeSelection = temp;
+}
+return treeSelection;
+}
+return null;
+}
+/**
+* Returns the number of selected items contained in the receiver.
+*
+* @return the number of selected items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public int getSelectionCount () {
+checkWidget();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+if (OS.GTK_VERSION < OS.buildVERSION (2, 2, 0)) {
+display.treeSelectionLength = 0;
+display.treeSelection = null;
+display.doTreeSelectionProcConnect( &treeSelectionCallbackData, handle, selection );
+return display.treeSelectionLength;
+}
+return OS.gtk_tree_selection_count_selected_rows (selection);
+}
+/**
+* Returns the column which shows the sort indicator for
+* the receiver. The value may be null if no column shows
+* the sort indicator.
+*
+* @return the sort indicator
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see #setSortColumn(TreeColumn)
+*
+* @since 3.2
+*/
+public TreeColumn getSortColumn () {
+checkWidget ();
+return sortColumn;
+}
+/**
+* Returns the direction of the sort indicator for the receiver.
+* The value will be one of <code>UP</code>, <code>DOWN</code>
+* or <code>NONE</code>.
+*
+* @return the sort direction
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see #setSortDirection(int)
+*
+* @since 3.2
+*/
+public int getSortDirection () {
+checkWidget ();
+return sortDirection;
+}
+GtkCellRendererText* getTextRenderer (GtkTreeViewColumn* column) {
+auto list = OS.gtk_tree_view_column_get_cell_renderers (column);
+if (list is null) return null;
+int count = OS.g_list_length (list);
+GtkCellRendererText* textRenderer;
+int i = 0;
+while (i < count) {
+auto renderer = OS.g_list_nth_data (list, i);
+if (OS.GTK_IS_CELL_RENDERER_TEXT (renderer)) {
+textRenderer = cast(GtkCellRendererText*)renderer;
+break;
+}
+i++;
+}
+OS.g_list_free (list);
+return textRenderer;
+}
+/**
+* Returns the item which is currently at the top of the receiver.
+* This item can change when items are expanded, collapsed, scrolled
+* or new items are added or removed.
+*
+* @return the item at the top of the receiver
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 2.1
+*/
+public TreeItem getTopItem () {
+checkWidget ();
+void* path;
+OS.gtk_widget_realize (handle);
+if (!OS.gtk_tree_view_get_path_at_pos (handle, 1, 1, &path, null, null, null)) return null;
+if (path  is null) return null;
+TreeItem item = null;
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, path )) {
+item = _getItem (&iter);
+}
+OS.gtk_tree_path_free (path );
+return item;
+}
+override int gtk_button_press_event (GtkWidget* widget, GdkEventButton* gdkEvent) {
+if (gdkEvent.window !is OS.gtk_tree_view_get_bin_window (handle)) return 0;
+auto result = super.gtk_button_press_event (widget, gdkEvent);
+if (result !is 0) return result;
+/*
+* Feature in GTK.  In a multi-select tree view, when multiple items are already
+* selected, the selection state of the item is toggled and the previous selection
+* is cleared. This is not the desired behaviour when bringing up a popup menu.
+* Also, when an item is reselected with the right button, the tree view issues
+* an unwanted selection event. The workaround is to detect that case and not
+* run the default handler when the item is already part of the current selection.
+*/
+int button = gdkEvent.button;
+if (button is 3 && gdkEvent.type is OS.GDK_BUTTON_PRESS) {
+void* path;
+if (OS.gtk_tree_view_get_path_at_pos (handle, cast(int)gdkEvent.x, cast(int)gdkEvent.y, &path, null, null, null)) {
+if (path !is null) {
+auto selection = OS.gtk_tree_view_get_selection (handle);
+if (OS.gtk_tree_selection_path_is_selected (selection, path )) result = 1;
+OS.gtk_tree_path_free (path );
+}
+}
+}
+/*
+* Feature in GTK.  When the user clicks in a single selection GtkTreeView
+* and there are no selected items, the first item is selected automatically
+* before the click is processed, causing two selection events.  The is fix
+* is the set the cursor item to be same as the clicked item to stop the
+* widget from automatically selecting the first item.
+*/
+if ((style & SWT.SINGLE) !is 0 && getSelectionCount () is 0) {
+void* path;
+if (OS.gtk_tree_view_get_path_at_pos (handle, cast(int)gdkEvent.x, cast(int)gdkEvent.y, &path, null, null, null)) {
+if (path  !is null) {
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_view_set_cursor (handle, path , null, false);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_path_free (path );
+}
+}
+}
+/*
+* Bug in GTK. GTK segments fault, if the GtkTreeView widget is
+* not in focus and all items in the widget are disposed before
+* it finishes processing a button press.  The fix is to give
+* focus to the widget before it starts processing the event.
+*/
+if (!OS.GTK_WIDGET_HAS_FOCUS (handle)) {
+OS.gtk_widget_grab_focus (handle);
+}
+return result;
+}
+override int gtk_button_release_event (GtkWidget* widget, GdkEventButton* event) {
+auto window = OS.GDK_EVENT_WINDOW (event);
+if (window !is OS.gtk_tree_view_get_bin_window (handle)) return 0;
+return super.gtk_button_release_event (widget, event);
+}
+override int gtk_changed (GtkWidget* widget) {
+TreeItem item = getFocusItem ();
+if (item !is null) {
+Event event = new Event ();
+event.item = item;
+postEvent (SWT.Selection, event);
+}
+return 0;
+}
+override int gtk_expand_collapse_cursor_row (GtkWidget* widget, int /*long*/ logical, int /*long*/ expand, int /*long*/ open_all) {
+// FIXME - this flag is never cleared.  It should be cleared when the expand all operation completes.
+if (expand !is 0 && open_all !is 0) expandAll = true;
+return 0;
+}
+override int gtk_key_press_event (GtkWidget* widget, GdkEventKey* keyEvent) {
+auto result = super.gtk_key_press_event (widget, keyEvent);
+if (result !is 0) return result;
+if (OS.GTK_VERSION < OS.buildVERSION (2, 2 ,0)) {
+/*
+* Feature in GTK 2.0.x.  When an item is default selected using
+* the return key, GTK does not issue notification. The fix is
+* to issue this notification when the return key is pressed.
+*/
+int key = keyEvent.keyval;
+switch (key) {
+case OS.GDK_Return:
+case OS.GDK_KP_Enter: {
+Event event = new Event ();
+event.item = getFocusItem ();
+postEvent (SWT.DefaultSelection, event);
+break;
+}
+default:
+}
+}
+return result;
+}
+override int gtk_motion_notify_event (GtkWidget* widget, GdkEventMotion* event) {
+auto window = OS.GDK_EVENT_WINDOW (event);
+if (window !is OS.gtk_tree_view_get_bin_window (handle)) return 0;
+return super.gtk_motion_notify_event (widget, event);
+}
+override int gtk_popup_menu (GtkWidget* widget) {
+auto result = super.gtk_popup_menu (widget);
+/*
+* Bug in GTK.  The context menu for the typeahead in GtkTreeViewer
+* opens in the bottom right corner of the screen when Shift+F10
+* is pressed and the typeahead window was not visible.  The fix is
+* to prevent the context menu from opening by stopping the default
+* handler.
+*
+* NOTE: The bug only happens in GTK 2.6.5 and lower.
+*/
+return OS.GTK_VERSION < OS.buildVERSION (2, 6, 5) ? 1 : result;
+}
+override void gtk_row_activated (GtkTreeView* tree, GtkTreePath* path, GtkTreeViewColumn* column) {
+if (path is null) return 0;
+TreeItem item = null;
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, path)) {
+int index;
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&index);
+item = items [index ];
+}
+Event event = new Event ();
+event.item = item;
+postEvent (SWT.DefaultSelection, event);
+return 0;
+}
+override int gtk_test_collapse_row (
+GtkTreeView *tree,
+GtkTreeIter *iter,
+GtkTreePath *path)
+{
+int index ;
+OS.gtk_tree_model_get1 (modelHandle, iter, ID_COLUMN, cast(void**)&index);
+TreeItem item = items [index ];
+Event event = new Event ();
+event.item = item;
+bool oldModelChanged = modelChanged;
+modelChanged = false;
+sendEvent (SWT.Collapse, event);
+/*
+* Bug in GTK.  Collapsing the target row during the test_collapse_row
+* handler will cause a segmentation fault if the animation code is allowed
+* to run.  The fix is to block the animation if the row is already
+* collapsed.
+*/
+bool changed = modelChanged || !OS.gtk_tree_view_row_expanded (handle, path);
+modelChanged = oldModelChanged;
+if (isDisposed () || item.isDisposed ()) return 1;
+/*
+* Bug in GTK.  Expanding or collapsing a row which has no more
+* children causes the model state to become invalid, causing
+* GTK to give warnings and behave strangely.  Other changes to
+* the model can cause expansion to fail when using the multiple
+* expansion keys (such as *).  The fix is to stop the expansion
+* if there are model changes.
+*
+* Note: This callback must return 0 for the collapsing
+* animation to occur.
+*/
+if (changed) {
+OS.g_signal_handlers_block_matched (handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udTEST_COLLAPSE_ROW);
+OS.gtk_tree_view_collapse_row (handle, path);
+OS.g_signal_handlers_unblock_matched (handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udTEST_COLLAPSE_ROW);
+return 1;
+}
+return 0;
+}
+override int gtk_test_expand_row (
+GtkTreeView *tree,
+GtkTreeIter *iter,
+GtkTreePath *path)
+{
+int index ;
+OS.gtk_tree_model_get1 (modelHandle, iter, ID_COLUMN, cast(void**)&index);
+TreeItem item = items [index ];
+Event event = new Event ();
+event.item = item;
+bool oldModelChanged = modelChanged;
+modelChanged = false;
+sendEvent (SWT.Expand, event);
+/*
+* Bug in GTK.  Expanding the target row during the test_expand_row
+* handler will cause a segmentation fault if the animation code is allowed
+* to run.  The fix is to block the animation if the row is already
+* expanded.
+*/
+bool changed = modelChanged || OS.gtk_tree_view_row_expanded (handle, path);
+modelChanged = oldModelChanged;
+if (isDisposed () || item.isDisposed ()) return 1;
+/*
+* Bug in GTK.  Expanding or collapsing a row which has no more
+* children causes the model state to become invalid, causing
+* GTK to give warnings and behave strangely.  Other changes to
+* the model can cause expansion to fail when using the multiple
+* expansion keys (such as *).  The fix is to stop the expansion
+* if there are model changes.
+*
+* Bug in GTK.  test-expand-row does not get called for each row
+* in an expand all operation.  The fix is to block the initial
+* expansion and only expand a single level.
+*
+* Note: This callback must return 0 for the collapsing
+* animation to occur.
+*/
+if (changed || expandAll) {
+OS.g_signal_handlers_block_matched (handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udTEST_EXPAND_ROW);
+OS.gtk_tree_view_expand_row (handle, path, false);
+OS.g_signal_handlers_unblock_matched (handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udTEST_EXPAND_ROW);
+return 1;
+}
+return 0;
+}
+override int gtk_toggled (int /*long*/ renderer, char* pathStr) {
+auto path = OS.gtk_tree_path_new_from_string (pathStr);
+if (path is null) return 0;
+TreeItem item = null;
+GtkTreeIter iter;
+if (OS.gtk_tree_model_get_iter (modelHandle, &iter, path)) {
+item = _getItem (&iter);
+}
+OS.gtk_tree_path_free (path);
+if (item !is null) {
+item.setChecked (!item.getChecked ());
+Event event = new Event ();
+event.detail = SWT.CHECK;
+event.item = item;
+postEvent (SWT.Selection, event);
+}
+return 0;
+}
+override void gtk_widget_size_request (GtkWidget* widget, GtkRequisition* requisition) {
+/*
+* Bug in GTK.  For some reason, gtk_widget_size_request() fails
+* to include the height of the tree view items when there are
+* no columns visible.  The fix is to temporarily make one column
+* visible.
+*/
+if (columnCount is 0) {
+super.gtk_widget_size_request (widget, requisition);
+return;
+}
+auto columns = OS.gtk_tree_view_get_columns (handle), list = columns;
+bool fixVisible = columns !is null;
+while (list !is null) {
+auto column = OS.g_list_data (list);
+if (OS.gtk_tree_view_column_get_visible (column)) {
+fixVisible = false;
+break;
+}
+list = OS.g_list_next (list);
+}
+GtkTreeViewColumn* columnHandle;
+if (fixVisible) {
+columnHandle = cast(GtkTreeViewColumn*)OS.g_list_data (columns);
+OS.gtk_tree_view_column_set_visible (columnHandle, true);
+}
+super.gtk_widget_size_request (widget, requisition);
+if (fixVisible) {
+OS.gtk_tree_view_column_set_visible (columnHandle, false);
+}
+if (columns !is null) OS.g_list_free (columns);
+}
+void hideFirstColumn () {
+auto firstColumn = OS.gtk_tree_view_get_column (handle, 0);
+OS.gtk_tree_view_column_set_visible (firstColumn, false);
+}
+override void hookEvents () {
+super.hookEvents ();
+auto selection = OS.gtk_tree_view_get_selection(handle);
+OS.g_signal_connect_closure (selection, OS.changed.ptr, display.closures [CHANGED], false);
+OS.g_signal_connect_closure (handle, OS.row_activated.ptr, display.closures [ROW_ACTIVATED], false);
+OS.g_signal_connect_closure (handle, OS.test_expand_row.ptr, display.closures [TEST_EXPAND_ROW], false);
+OS.g_signal_connect_closure (handle, OS.test_collapse_row.ptr, display.closures [TEST_COLLAPSE_ROW], false);
+OS.g_signal_connect_closure (handle, OS.expand_collapse_cursor_row.ptr, display.closures [EXPAND_COLLAPSE_CURSOR_ROW], false);
+if (checkRenderer !is null) {
+OS.g_signal_connect_closure (checkRenderer, OS.toggled.ptr, display.closures [TOGGLED], false);
+}
+}
+/**
+* Searches the receiver's list starting at the first column
+* (index 0) until a column is found that is equal to the
+* argument, and returns the index of that column. If no column
+* is found, returns -1.
+*
+* @param column the search column
+* @return the index of the column
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the column is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public int indexOf (TreeColumn column) {
+checkWidget();
+if (column is null) error (SWT.ERROR_NULL_ARGUMENT);
+for (int i=0; i<columnCount; i++) {
+if (columns [i] is column) return i;
+}
+return -1;
+}
+/**
+* Searches the receiver's list starting at the first item
+* (index 0) until an item is found that is equal to the
+* argument, and returns the index of that item. If no item
+* is found, returns -1.
+*
+* @param item the search item
+* @return the index of the item
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public int indexOf (TreeItem item) {
+checkWidget();
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (item.isDisposed()) error (SWT.ERROR_INVALID_ARGUMENT);
+int index = -1;
+auto path = OS.gtk_tree_model_get_path (modelHandle, item.handle);
+int depth = OS.gtk_tree_path_get_depth (path);
+if (depth is 1) {
+auto indices = OS.gtk_tree_path_get_indices (path);
+if (indices !is null) {
+index = indices[0];
+}
+}
+OS.gtk_tree_path_free (path);
+return index;
+}
+override bool mnemonicHit (wchar key) {
+for (int i=0; i<columnCount; i++) {
+auto labelHandle = columns [i].labelHandle;
+if (labelHandle !is null && mnemonicHit (labelHandle, key)) return true;
+}
+return false;
+}
+override bool mnemonicMatch (wchar key) {
+for (int i=0; i<columnCount; i++) {
+auto labelHandle = columns [i].labelHandle;
+if (labelHandle !is null && mnemonicMatch (labelHandle, key)) return true;
+}
+return false;
+}
+override GdkDrawable* paintWindow () {
+OS.gtk_widget_realize (handle);
+return OS.gtk_tree_view_get_bin_window (handle);
+}
+void recreateRenderers () {
+if (checkRenderer !is null) {
+display.removeWidget (cast(GtkWidget*)checkRenderer);
+OS.g_object_unref (checkRenderer);
+checkRenderer = ownerDraw ? cast(GtkCellRenderer*)OS.g_object_new (display.gtk_cell_renderer_toggle_get_type(), null) : OS.gtk_cell_renderer_toggle_new ();
+if (checkRenderer is null) error (SWT.ERROR_NO_HANDLES);
+OS.g_object_ref (checkRenderer);
+display.addWidget (cast(GtkWidget*)checkRenderer, this);
+OS.g_signal_connect_closure (checkRenderer, OS.toggled.ptr, display.closures [TOGGLED], false);
+}
+if (columnCount is 0) {
+createRenderers (OS.gtk_tree_view_get_column (handle, 0), Tree.FIRST_COLUMN, true, 0);
+} else {
+for (int i = 0; i < columnCount; i++) {
+TreeColumn column = columns [i];
+createRenderers (cast(GtkTreeViewColumn*)column.handle, column.modelIndex, i is 0, column.style);
+}
+}
+}
+override void redrawBackgroundImage () {
+Control control = findBackgroundControl ();
+if (control !is null && control.backgroundImage !is null) {
+redrawWidget (0, 0, 0, 0, true, false, false);
+}
+}
+override void register () {
+super.register ();
+display.addWidget (cast(GtkWidget*)OS.gtk_tree_view_get_selection (handle), this);
+if (checkRenderer !is null) display.addWidget (cast(GtkWidget*)checkRenderer, this);
+}
+void releaseItem (TreeItem item, bool release) {
+int index;
+OS.gtk_tree_model_get1 (modelHandle, item.handle, ID_COLUMN, cast(void**)&index);
+if (index is -1) return;
+if (release) item.release (false);
+items [index ] = null;
+}
+void releaseItems (GtkTreeIter* parentIter) {
+int index;
+GtkTreeIter iter;
+bool valid = cast(bool)OS.gtk_tree_model_iter_children (modelHandle, &iter, parentIter);
+while (valid) {
+releaseItems (&iter);
+if (!isDisposed ()) {
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&index);
+if (index  !is -1) {
+TreeItem item = items [index ];
+if (item !is null) releaseItem (item, true);
+}
+}
+valid = cast(bool)OS.gtk_tree_model_iter_next (modelHandle, &iter);
+}
+}
+override void releaseChildren (bool destroy) {
+if (items !is null) {
+for (int i=0; i<items.length; i++) {
+TreeItem item = items [i];
+if (item !is null && !item.isDisposed ()) {
+item.release (false);
+}
+}
+items = null;
+}
+if (columns !is null) {
+for (int i=0; i<columnCount; i++) {
+TreeColumn column = columns [i];
+if (column !is null && !column.isDisposed ()) {
+column.release (false);
+}
+}
+columns = null;
+}
+super.releaseChildren (destroy);
+}
+override void releaseWidget () {
+super.releaseWidget ();
+if (modelHandle !is null) OS.g_object_unref (modelHandle);
+modelHandle = null;
+if (checkRenderer !is null) OS.g_object_unref (checkRenderer);
+checkRenderer = null;
+if (imageList !is null) imageList.dispose ();
+if (headerImageList !is null) headerImageList.dispose ();
+imageList = headerImageList = null;
+currentItem = null;
+}
+void remove (GtkTreeIter* parentIter, int start, int end) {
+if (start > end) return;
+int itemCount = OS.gtk_tree_model_iter_n_children (modelHandle, parentIter);
+if (!(0 <= start && start <= end && end < itemCount)) {
+error (SWT.ERROR_INVALID_RANGE);
+}
+auto selection = OS.gtk_tree_view_get_selection (handle);
+GtkTreeIter iter;
+int index = start;
+for (int i = start; i <= end; i++) {
+OS.gtk_tree_model_iter_nth_child (modelHandle, &iter, parentIter, index);
+int value;
+OS.gtk_tree_model_get1 (modelHandle, &iter, ID_COLUMN, cast(void**)&value);
+TreeItem item = value  !is -1 ? items [value ] : null;
+if (item !is null && !item.isDisposed ()) {
+item.dispose ();
+} else {
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_store_remove (modelHandle, &iter);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+}
+}
+}
+/**
+* Removes all of the items from the receiver.
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public void removeAll () {
+checkWidget ();
+for (int i=0; i<items.length; i++) {
+TreeItem item = items [i];
+if (item !is null && !item.isDisposed ()) item.release (false);
+}
+items = new TreeItem[4];
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_store_clear (modelHandle);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+/* Disable searching when using VIRTUAL */
+if ((style & SWT.VIRTUAL) !is 0) {
+/*
+* Bug in GTK. Until GTK 2.6.5, calling gtk_tree_view_set_enable_search(FALSE)
+* would prevent the user from being able to type in text to search the tree.
+* After 2.6.5, GTK introduced Ctrl+F as being the key binding for interactive
+* search. This meant that even if FALSE was passed to enable_search, the user
+* can still bring up the search pop up using the keybinding. GTK also introduced
+* the notion of passing a -1 to gtk_set_search_column to disable searching
+* (including the search key binding).  The fix is to use the right calls
+* for the right version.
+*/
+if (OS.GTK_VERSION >= OS.buildVERSION (2, 6, 5)) {
+OS.gtk_tree_view_set_search_column (handle, -1);
+} else {
+OS.gtk_tree_view_set_enable_search (handle, false);
+}
+} else {
+/* Set the search column whenever the model changes */
+int firstColumn = columnCount is 0 ? FIRST_COLUMN : columns [0].modelIndex;
+OS.gtk_tree_view_set_search_column (handle, firstColumn + CELL_TEXT);
+}
+}
+/**
+* Removes the listener from the collection of listeners who will
+* be notified when the user changes the receiver's selection.
+*
+* @param listener the listener which should no longer be notified
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see SelectionListener
+* @see #addSelectionListener
+*/
+public void removeSelectionListener (SelectionListener listener) {
+checkWidget ();
+if (listener is null) error (SWT.ERROR_NULL_ARGUMENT);
+eventTable.unhook (SWT.Selection, listener);
+eventTable.unhook (SWT.DefaultSelection, listener);
+}
+/**
+* Removes the listener from the collection of listeners who will
+* be notified when items in the receiver are expanded or collapsed.
+*
+* @param listener the listener which should no longer be notified
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see TreeListener
+* @see #addTreeListener
+*/
+public void removeTreeListener(TreeListener listener) {
+checkWidget ();
+if (listener is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (eventTable is null) return;
+eventTable.unhook (SWT.Expand, listener);
+eventTable.unhook (SWT.Collapse, listener);
+}
+override void rendererGetSizeProc (
+GtkCellRenderer      *cell,
+GtkWidget            *widget,
+GdkRectangle         *cell_area,
+int                  *x_offset,
+int                  *y_offset,
+int                  *width,
+int                  *height)
+{
+auto g_class = OS.g_type_class_peek_parent (OS.G_OBJECT_GET_CLASS (cell));
+GtkCellRendererClass* klass = cast(GtkCellRendererClass*)g_class;
+klass.get_size( cell, handle, cell_area, x_offset, y_offset, width, height);
+if (!ignoreSize && OS.GTK_IS_CELL_RENDERER_TEXT (cell)) {
+auto iter = cast(GtkTreeIter*)OS.g_object_get_qdata (cast(GObject*)cell, Display.SWT_OBJECT_INDEX2);
+TreeItem item = null;
+if (iter !is null) item = _getItem (iter);
+if (item !is null) {
+int columnIndex = 0;
+if (columnCount > 0) {
+auto columnHandle = cast(GtkTreeViewColumn*)OS.g_object_get_qdata (cast(GObject*)cell, Display.SWT_OBJECT_INDEX1);
+for (int i = 0; i < columnCount; i++) {
+if (columns [i].handle is cast(GtkWidget*)columnHandle) {
+columnIndex = i;
+break;
+}
+}
+}
+if (hooks (SWT.MeasureItem)) {
+int contentWidth, contentHeight;
+if (width !is null) contentWidth = *width;
+if (height !is null) contentHeight = *height;
+Image image = item.getImage (columnIndex);
+int imageWidth = 0;
+if (image !is null) {
+Rectangle bounds = image.getBounds ();
+imageWidth = bounds.width;
+}
+contentWidth += imageWidth;
+GC gc = new GC (this);
+gc.setFont (item.getFont (columnIndex));
+Event event = new Event ();
+event.item = item;
+event.index = columnIndex;
+event.gc = gc;
+event.width = contentWidth ;
+event.height = contentHeight ;
+sendEvent (SWT.MeasureItem, event);
+gc.dispose ();
+contentWidth  = event.width - imageWidth;
+if (contentHeight < event.height) contentHeight = event.height;
+if (width !is null) *width = contentWidth;
+if (height !is null) *height = contentHeight;
+}
+}
+}
+}
+override void rendererRenderProc (
+GtkCellRenderer * cell,
+GdkDrawable * window,
+GtkWidget * widget,
+GdkRectangle *background_area,
+GdkRectangle *cell_area,
+GdkRectangle *expose_area,
+int flags)
+{
+TreeItem item = null;
+auto iter = cast(GtkTreeIter*)OS.g_object_get_qdata (cast(GObject*)cell, Display.SWT_OBJECT_INDEX2);
+if (iter !is null) item = _getItem (iter);
+auto columnHandle = cast(GtkTreeViewColumn*)OS.g_object_get_qdata (cast(GObject*)cell, Display.SWT_OBJECT_INDEX1);
+int columnIndex = 0;
+if (columnCount > 0) {
+for (int i = 0; i < columnCount; i++) {
+if (columns [i].handle is cast(GtkWidget*)columnHandle) {
+columnIndex = i;
+break;
+}
+}
+}
+if (item !is null) {
+if (OS.GTK_IS_CELL_RENDERER_TOGGLE (cell) || (OS.GTK_IS_CELL_RENDERER_PIXBUF (cell) && (columnIndex !is 0 || (style & SWT.CHECK) is 0))) {
+drawFlags = cast(int)/*64*/flags;
+drawState = SWT.FOREGROUND;
+void* ptr;
+OS.gtk_tree_model_get1 (modelHandle, item.handle, Tree.BACKGROUND_COLUMN, &ptr);
+if (ptr is null) {
+int modelIndex = columnCount is 0 ? Tree.FIRST_COLUMN : columns [columnIndex].modelIndex;
+OS.gtk_tree_model_get1 (modelHandle, item.handle, modelIndex + Tree.CELL_BACKGROUND, &ptr);
+}
+if (ptr !is null) drawState |= SWT.BACKGROUND;
+if ((flags & OS.GTK_CELL_RENDERER_SELECTED) !is 0) drawState |= SWT.SELECTED;
+if ((flags & OS.GTK_CELL_RENDERER_FOCUSED) !is 0) drawState |= SWT.FOCUSED;
+GdkRectangle rect;
+auto path = OS.gtk_tree_model_get_path (modelHandle, iter);
+OS.gtk_tree_view_get_background_area (handle, path, columnHandle, &rect);
+OS.gtk_tree_path_free (path);
+if ((drawState & SWT.SELECTED) is 0) {
+Control control = findBackgroundControl ();
+if (control !is null && control.backgroundImage !is null) {
+OS.gdk_window_clear_area (window, rect.x, rect.y, rect.width, rect.height);
+}
+}
+if (hooks (SWT.EraseItem)) {
+bool wasSelected = false;
+if ((drawState & SWT.SELECTED) !is 0) {
+wasSelected = true;
+OS.gdk_window_clear_area (window, rect.x, rect.y, rect.width, rect.height);
+}
+GC gc = new GC (this);
+if ((drawState & SWT.SELECTED) !is 0) {
+gc.setBackground (display.getSystemColor (SWT.COLOR_LIST_SELECTION));
+gc.setForeground (display.getSystemColor (SWT.COLOR_LIST_SELECTION_TEXT));
+} else {
+gc.setBackground (item.getBackground (columnIndex));
+gc.setForeground (item.getForeground (columnIndex));
+}
+gc.setFont (item.getFont (columnIndex));
+if ((style & SWT.MIRRORED) !is 0) rect.x = getClientWidth () - rect.width - rect.x;
+gc.setClipping (rect.x, rect.y, rect.width, rect.height);
+Event event = new Event ();
+event.item = item;
+event.index = columnIndex;
+event.gc = gc;
+event.x = rect.x;
+event.y = rect.y;
+event.width = rect.width;
+event.height = rect.height;
+event.detail = drawState;
+sendEvent (SWT.EraseItem, event);
+drawForeground = null;
+drawState = event.doit ? event.detail : 0;
+drawFlags &= ~(OS.GTK_CELL_RENDERER_FOCUSED | OS.GTK_CELL_RENDERER_SELECTED);
+if ((drawState & SWT.SELECTED) !is 0) drawFlags |= OS.GTK_CELL_RENDERER_SELECTED;
+if ((drawState & SWT.FOCUSED) !is 0) drawFlags |= OS.GTK_CELL_RENDERER_FOCUSED;
+if ((drawState & SWT.SELECTED) !is 0) {
+auto style = OS.gtk_widget_get_style (widget);
+//TODO - parity and sorted
+OS.gtk_paint_flat_box (style, window, OS.GTK_STATE_SELECTED, OS.GTK_SHADOW_NONE, &rect, widget, "cell_odd".ptr, rect.x, rect.y, rect.width, rect.height);
+} else {
+if (wasSelected) drawForeground = gc.getForeground ().handle;
+}
+gc.dispose();
+}
+}
+}
+int /*long*/ result = 0;
+if ((drawState & SWT.BACKGROUND) !is 0 && (drawState & SWT.SELECTED) is 0) {
+GC gc = new GC (this);
+gc.setBackground (item.getBackground (columnIndex));
+gc.fillRectangle (background_area.x, background_area.y, background_area.width, background_area.height);
+gc.dispose ();
+}
+if ((drawState & SWT.FOREGROUND) !is 0 || OS.GTK_IS_CELL_RENDERER_TOGGLE (cell)) {
+auto g_class = OS.g_type_class_peek_parent (OS.G_OBJECT_GET_CLASS (cell));
+GtkCellRendererClass* klass = cast(GtkCellRendererClass*)g_class;
+if (drawForeground !is null && OS.GTK_IS_CELL_RENDERER_TEXT (cell)) {
+OS.g_object_set1 (cell, OS.foreground_gdk.ptr, cast(int)drawForeground);
+}
+klass.render( cell, window, handle, background_area, cell_area, expose_area, drawFlags);
+}
+if (item !is null) {
+if (OS.GTK_IS_CELL_RENDERER_TEXT (cell)) {
+if (hooks (SWT.PaintItem)) {
+GdkRectangle rect;
+auto path = OS.gtk_tree_model_get_path (modelHandle, iter);
+OS.gtk_tree_view_get_cell_area (handle, path, columnHandle, &rect);
+OS.gtk_tree_path_free (path);
+if (OS.GTK_VERSION < OS.buildVERSION (2, 8, 18) && OS.gtk_tree_view_get_expander_column (handle) is columnHandle) {
+int buffer;
+OS.gtk_widget_style_get1 (handle, OS.expander_size.ptr, &buffer);
+rect.x += buffer + TreeItem.EXPANDER_EXTRA_PADDING;
+rect.width -= buffer + TreeItem.EXPANDER_EXTRA_PADDING;
+//OS.gtk_widget_style_get (handle, OS.horizontal_separator, buffer, 0);
+//rect.x += buffer[0];
+//rect.width -= buffer [0]; // TODO Is this required for some versions?
+}
+ignoreSize = true;
+int contentX, contentWidth;
+OS.gtk_cell_renderer_get_size (cell, handle, null, null, null, &contentWidth, null);
+OS.gtk_tree_view_column_cell_get_position (columnHandle, cell, &contentX, null);
+ignoreSize = false;
+Image image = item.getImage (columnIndex);
+int imageWidth = 0;
+if (image !is null) {
+Rectangle bounds = image.getBounds ();
+imageWidth = bounds.width;
+}
+contentX -= imageWidth;
+contentWidth += imageWidth;
+GC gc = new GC (this);
+if ((drawState & SWT.SELECTED) !is 0) {
+gc.setBackground (display.getSystemColor (SWT.COLOR_LIST_SELECTION));
+gc.setForeground (display.getSystemColor (SWT.COLOR_LIST_SELECTION_TEXT));
+} else {
+gc.setBackground (item.getBackground (columnIndex));
+Color foreground = drawForeground !is null ? Color.gtk_new (display, drawForeground) : item.getForeground (columnIndex);
+gc.setForeground (foreground);
+}
+gc.setFont (item.getFont (columnIndex));
+if ((style & SWT.MIRRORED) !is 0) rect.x = getClientWidth () - rect.width - rect.x;
+gc.setClipping (rect.x, rect.y, rect.width, rect.height);
+Event event = new Event ();
+event.item = item;
+event.index = columnIndex;
+event.gc = gc;
+event.x = rect.x + contentX;
+event.y = rect.y;
+event.width = contentWidth;
+event.height = rect.height;
+event.detail = drawState;
+sendEvent (SWT.PaintItem, event);
+gc.dispose();
+}
+}
+}
+return result;
+}
+void resetCustomDraw () {
+if ((style & SWT.VIRTUAL) !is 0 || ownerDraw) return;
+int end = Math.max (1, columnCount);
+for (int i=0; i<end; i++) {
+bool customDraw = columnCount !is 0 ? columns [i].customDraw : firstCustomDraw;
+if (customDraw) {
+auto column = OS.gtk_tree_view_get_column (handle, i);
+auto textRenderer = getTextRenderer (column);
+OS.gtk_tree_view_column_set_cell_data_func (column, textRenderer, null, null, null);
+if (columnCount !is 0) columns [i].customDraw = false;
+}
+}
+firstCustomDraw = false;
+}
+/**
+* Display a mark indicating the point at which an item will be inserted.
+* The drop insert item has a visual hint to show where a dragged item
+* will be inserted when dropped on the tree.
+*
+* @param item the insert item.  Null will clear the insertion mark.
+* @param before true places the insert mark above 'item'. false places
+*  the insert mark below 'item'.
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public void setInsertMark (TreeItem item, bool before) {
+checkWidget ();
+if (item is null) {
+OS.gtk_tree_view_set_drag_dest_row(handle, null, OS.GTK_TREE_VIEW_DROP_BEFORE);
+return;
+}
+if (item.isDisposed()) error (SWT.ERROR_INVALID_ARGUMENT);
+if (item.parent !is this) return;
+Rectangle rect = item.getBounds();
+void* path;
+OS.gtk_widget_realize (handle);
+if (!OS.gtk_tree_view_get_path_at_pos(handle, rect.x, rect.y, &path, null, null, null)) return;
+if (path is null) return;
+int position = before ? OS.GTK_TREE_VIEW_DROP_BEFORE : OS.GTK_TREE_VIEW_DROP_AFTER;
+OS.gtk_tree_view_set_drag_dest_row(handle, path, position);
+OS.gtk_tree_path_free (path );
+}
+void setItemCount (GtkTreeIter* parentIter, int count) {
+int itemCount = OS.gtk_tree_model_iter_n_children (modelHandle, parentIter);
+if (count is itemCount) return;
+bool isVirtual = (style & SWT.VIRTUAL) !is 0;
+if (!isVirtual) setRedraw (false);
+remove (parentIter, count, itemCount - 1);
+if (isVirtual) {
+for (int i=itemCount; i<count; i++) {
+GtkTreeIter iter;
+OS.gtk_tree_store_append (modelHandle, &iter, parentIter);
+OS.gtk_tree_store_set1 (modelHandle, &iter, ID_COLUMN, cast(void*)-1);
+}
+} else {
+for (int i=itemCount; i<count; i++) {
+new TreeItem (this, parentIter, SWT.NONE, i, true);
+}
+}
+if (!isVirtual) setRedraw (true);
+modelChanged = true;
+}
+/**
+* Sets the number of root-level items contained in the receiver.
+*
+* @param count the number of items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.2
+*/
+public void setItemCount (int count) {
+checkWidget ();
+count = Math.max (0, count);
+setItemCount (null, count);
+}
+/**
+* Selects an item in the receiver.  If the item was already
+* selected, it remains selected.
+*
+* @param item the item to be selected
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.4
+*/
+public void select (TreeItem item) {
+checkWidget ();
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (item.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
+bool fixColumn = showFirstColumn ();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_selection_select_iter (selection, item.handle);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+if (fixColumn) hideFirstColumn ();
+}
+/**
+* Selects all of the items in the receiver.
+* <p>
+* If the receiver is single-select, do nothing.
+* </p>
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*/
+public void selectAll () {
+checkWidget();
+if ((style & SWT.SINGLE) !is 0) return;
+bool fixColumn = showFirstColumn ();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+OS.gtk_tree_selection_select_all (selection);
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+if (fixColumn) hideFirstColumn ();
+}
+override void setBackgroundColor (GdkColor* color) {
+super.setBackgroundColor (color);
+OS.gtk_widget_modify_base (handle, 0, color);
+}
+override void setBackgroundPixmap (GdkPixmap* pixmap) {
+super.setBackgroundPixmap (pixmap);
+auto window = paintWindow ();
+if (window !is null) OS.gdk_window_set_back_pixmap (window, null, true);
+}
+override int setBounds (int x, int y, int width, int height, bool move, bool resize) {
+int result = super.setBounds (x, y, width, height, move, resize);
+/*
+* Bug on GTK.  The tree view sometimes does not get a paint
+* event or resizes to a one pixel square when resized in a new
+* shell that is not visible after any event loop has been run.  The
+* problem is intermittent. It doesn't seem to happen the first time
+* a new shell is created. The fix is to ensure the tree view is realized
+* after it has been resized.
+*/
+OS.gtk_widget_realize (handle);
+/*
+* Bug in GTK.  An empty GtkTreeView fails to repaint the focus rectangle
+* correctly when resized on versions before 2.6.0.  The fix is to force
+* the widget to redraw.
+*/
+if (OS.GTK_VERSION < OS.buildVERSION (2, 6, 0) && OS.gtk_tree_model_iter_n_children (modelHandle, null) is 0) {
+redraw (false);
+}
+return result;
+}
+/**
+* Sets the order that the items in the receiver should
+* be displayed in to the given argument which is described
+* in terms of the zero-relative ordering of when the items
+* were added.
+*
+* @param order the new order to display the items
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if the item order is not the same length as the number of items</li>
+* </ul>
+*
+* @see Tree#getColumnOrder()
+* @see TreeColumn#getMoveable()
+* @see TreeColumn#setMoveable(bool)
+* @see SWT#Move
+*
+* @since 3.2
+*/
+public void setColumnOrder (int [] order) {
+checkWidget ();
+// SWT extension: allow null for zero length string
+//if (order is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (columnCount is 0) {
+if (order.length > 0) error (SWT.ERROR_INVALID_ARGUMENT);
+return;
+}
+if (order.length !is columnCount) error (SWT.ERROR_INVALID_ARGUMENT);
+bool [] seen = new bool [columnCount];
+for (int i = 0; i<order.length; i++) {
+int index = order [i];
+if (index < 0 || index >= columnCount) error (SWT.ERROR_INVALID_RANGE);
+if (seen [index]) error (SWT.ERROR_INVALID_ARGUMENT);
+seen [index] = true;
+}
+void* baseColumn;
+for (int i=0; i<order.length; i++) {
+auto column = columns [order [i]].handle;
+OS.gtk_tree_view_move_column_after (handle, column, baseColumn);
+baseColumn = column;
+}
+}
+override void setFontDescription (PangoFontDescription* font) {
+super.setFontDescription (font);
+TreeColumn[] columns = getColumns ();
+for (int i = 0; i < columns.length; i++) {
+if (columns[i] !is null) {
+columns[i].setFontDescription (font);
+}
+}
+}
+/**
+* Marks the receiver's header as visible if the argument is <code>true</code>,
+* and marks it invisible otherwise.
+* <p>
+* If one of the receiver's ancestors is not visible or some
+* other condition makes the receiver not visible, marking
+* it visible may not actually cause it to be displayed.
+* </p>
+*
+* @param show the new visibility state
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public void setHeaderVisible (bool show) {
+checkWidget ();
+OS.gtk_tree_view_set_headers_visible (handle, show);
+}
+/**
+* Marks the receiver's lines as visible if the argument is <code>true</code>,
+* and marks it invisible otherwise.
+* <p>
+* If one of the receiver's ancestors is not visible or some
+* other condition makes the receiver not visible, marking
+* it visible may not actually cause it to be displayed.
+* </p>
+*
+* @param show the new visibility state
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public void setLinesVisible (bool show) {
+checkWidget();
+OS.gtk_tree_view_set_rules_hint (handle, show);
+}
+override void setParentBackground () {
+super.setParentBackground ();
+auto window = paintWindow ();
+if (window !is null) OS.gdk_window_set_back_pixmap (window, null, true);
+}
+override void setParentWindow (GtkWidget* widget) {
+auto window = eventWindow ();
+OS.gtk_widget_set_parent_window (widget, window);
+}
+void setScrollWidth (GtkTreeViewColumn* column, TreeItem item) {
+if (columnCount !is 0 || currentItem is item) return;
+/*
+* Use GTK_TREE_VIEW_COLUMN_GROW_ONLY on GTK versions < 2.3.2
+* because fixed_height_mode is not supported.
+*/
+if (((style & SWT.VIRTUAL) !is 0) && OS.GTK_VERSION < OS.buildVERSION (2, 3, 2)) return;
+int width = OS.gtk_tree_view_column_get_fixed_width (column);
+int itemWidth = calculateWidth (column, cast(GtkTreeIter*)item.handle, true);
+if (width < itemWidth) {
+OS.gtk_tree_view_column_set_fixed_width (column, itemWidth);
+}
+}
+/**
+* Sets the receiver's selection to the given item.
+* The current selection is cleared before the new item is selected.
+* <p>
+* If the item is not in the receiver, then it is ignored.
+* </p>
+*
+* @param item the item to select
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.2
+*/
+public void setSelection (TreeItem item) {
+checkWidget ();
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+setSelection ([item]);
+}
+/**
+* Sets the receiver's selection to be the given array of items.
+* The current selection is cleared before the new items are selected.
+* <p>
+* Items that are not in the receiver are ignored.
+* If the receiver is single-select and multiple items are specified,
+* then all items are ignored.
+* </p>
+*
+* @param items the array of items
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if one of the items has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#deselectAll()
+*/
+public void setSelection (TreeItem [] items) {
+checkWidget ();
+// SWT extension: allow null for zero length string
+//if (items is null) error (SWT.ERROR_NULL_ARGUMENT);
+deselectAll ();
+int length = items.length;
+if (length is 0 || ((style & SWT.SINGLE) !is 0 && length > 1)) return;
+bool fixColumn = showFirstColumn ();
+auto selection = OS.gtk_tree_view_get_selection (handle);
+OS.g_signal_handlers_block_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+bool first = true;
+for (int i = 0; i < length; i++) {
+TreeItem item = items [i];
+if (item is null) continue;
+if (item.isDisposed ()) break;
+if (item.parent !is this) continue;
+auto path = OS.gtk_tree_model_get_path (modelHandle, item.handle);
+showItem (path, false);
+if (first) {
+OS.gtk_tree_view_set_cursor (handle, path, null, false);
+}
+OS.gtk_tree_selection_select_iter (selection, item.handle);
+OS.gtk_tree_path_free (path);
+first = false;
+}
+OS.g_signal_handlers_unblock_matched (selection, OS.G_SIGNAL_MATCH_DATA, 0, 0, null, null, udCHANGED);
+if (fixColumn) hideFirstColumn ();
+}
+/**
+* Sets the column used by the sort indicator for the receiver. A null
+* value will clear the sort indicator.  The current sort column is cleared
+* before the new column is set.
+*
+* @param column the column used by the sort indicator or <code>null</code>
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if the column is disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.2
+*/
+public void setSortColumn (TreeColumn column) {
+checkWidget ();
+if (column !is null && column.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
+if (sortColumn !is null && !sortColumn.isDisposed()) {
+OS.gtk_tree_view_column_set_sort_indicator (sortColumn.handle, false);
+}
+sortColumn = column;
+if (sortColumn !is null && sortDirection !is SWT.NONE) {
+OS.gtk_tree_view_column_set_sort_indicator (sortColumn.handle, true);
+OS.gtk_tree_view_column_set_sort_order (sortColumn.handle, sortDirection is SWT.DOWN ? 0 : 1);
+}
+}
+/**
+* Sets the direction of the sort indicator for the receiver. The value
+* can be one of <code>UP</code>, <code>DOWN</code> or <code>NONE</code>.
+*
+* @param direction the direction of the sort indicator
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.2
+*/
+public void setSortDirection  (int direction) {
+checkWidget ();
+if (direction !is SWT.UP && direction !is SWT.DOWN && direction !is SWT.NONE) return;
+sortDirection = direction;
+if (sortColumn is null || sortColumn.isDisposed ()) return;
+if (sortDirection is SWT.NONE) {
+OS.gtk_tree_view_column_set_sort_indicator (sortColumn.handle, false);
+} else {
+OS.gtk_tree_view_column_set_sort_indicator (sortColumn.handle, true);
+OS.gtk_tree_view_column_set_sort_order (sortColumn.handle, sortDirection is SWT.DOWN ? 0 : 1);
+}
+}
+/**
+* Sets the item which is currently at the top of the receiver.
+* This item can change when items are expanded, collapsed, scrolled
+* or new items are added or removed.
+*
+* @param item the item to be shown
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#getTopItem()
+*
+* @since 2.1
+*/
+public void setTopItem (TreeItem item) {
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (item.isDisposed ()) error(SWT.ERROR_INVALID_ARGUMENT);
+if (item.parent !is this) return;
+auto path = OS.gtk_tree_model_get_path (modelHandle, item.handle);
+showItem (path, false);
+OS.gtk_tree_view_scroll_to_cell (handle, path, null, true, 0f, 0f);
+if (OS.GTK_VERSION < OS.buildVERSION (2, 8, 0)) {
+/*
+* Bug in GTK.  According to the documentation, gtk_tree_view_scroll_to_cell
+* should vertically scroll the cell to the top if use_align is true and row_align is 0.
+* However, prior to version 2.8 it does not scroll at all.  The fix is to determine
+* the new location and use gtk_tree_view_scroll_to_point.
+* If the widget is a pinhead, calling gtk_tree_view_scroll_to_point
+* will have no effect. Therefore, it is still neccessary to call
+* gtk_tree_view_scroll_to_cell.
+*/
+OS.gtk_widget_realize (handle);
+GdkRectangle cellRect;
+OS.gtk_tree_view_get_cell_area (handle, path, null, &cellRect);
+int tx, ty;
+OS.gtk_tree_view_widget_to_tree_coords(handle, cellRect.x, cellRect.y, &tx, &ty);
+OS.gtk_tree_view_scroll_to_point (handle, -1, ty);
+}
+OS.gtk_tree_path_free (path);
+}
+/**
+* Shows the column.  If the column is already showing in the receiver,
+* this method simply returns.  Otherwise, the columns are scrolled until
+* the column is visible.
+*
+* @param column the column to be shown
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @since 3.1
+*/
+public void showColumn (TreeColumn column) {
+checkWidget ();
+if (column is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (column.isDisposed()) error(SWT.ERROR_INVALID_ARGUMENT);
+if (column.parent !is this) return;
+/*
+* This code is intentionally commented. According to the
+* documentation, gtk_tree_view_scroll_to_cell should scroll the
+* minimum amount to show the column but instead it scrolls strangely.
+*/
+//OS.gtk_tree_view_scroll_to_cell (handle, 0, column.handle, false, 0, 0);
+OS.gtk_widget_realize (handle);
+GdkRectangle cellRect;
+OS.gtk_tree_view_get_cell_area (handle, null, column.handle, &cellRect);
+GdkRectangle visibleRect;
+OS.gtk_tree_view_get_visible_rect (handle, &visibleRect);
+if (cellRect.x < visibleRect.x) {
+OS.gtk_tree_view_scroll_to_point (handle, cellRect.x, -1);
+} else {
+int width = Math.min (visibleRect.width, cellRect.width);
+if (cellRect.x + width > visibleRect.x + visibleRect.width) {
+int tree_x = cellRect.x + width - visibleRect.width;
+OS.gtk_tree_view_scroll_to_point (handle, tree_x, -1);
+}
+}
+}
+bool showFirstColumn () {
+/*
+* Bug in GTK.  If no columns are visible, changing the selection
+* will fail.  The fix is to temporarily make a column visible.
+*/
+int columnCount = Math.max (1, this.columnCount);
+for (int i=0; i<columnCount; i++) {
+auto column = OS.gtk_tree_view_get_column (handle, i);
+if (OS.gtk_tree_view_column_get_visible (column)) return false;
+}
+auto firstColumn = OS.gtk_tree_view_get_column (handle, 0);
+OS.gtk_tree_view_column_set_visible (firstColumn, true);
+return true;
+}
+/**
+* Shows the selection.  If the selection is already showing in the receiver,
+* this method simply returns.  Otherwise, the items are scrolled until
+* the selection is visible.
+*
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#showItem(TreeItem)
+*/
+public void showSelection () {
+checkWidget();
+TreeItem [] items = getSelection ();
+if (items.length !is 0 && items [0] !is null) showItem (items [0]);
+}
+void showItem (GtkTreePath* path, bool scroll) {
+int depth = OS.gtk_tree_path_get_depth (path);
+if (depth > 1) {
+auto indicesPtr = OS.gtk_tree_path_get_indices (path);
+int [] indices = indicesPtr[ 0 .. depth - 1];
+auto tempPath = OS.gtk_tree_path_new ();
+for (int i=0; i<indices.length; i++) {
+OS.gtk_tree_path_append_index (tempPath, indices [i]);
+OS.gtk_tree_view_expand_row (handle, tempPath, false);
+}
+OS.gtk_tree_path_free (tempPath);
+}
+if (scroll) {
+OS.gtk_widget_realize (handle);
+GdkRectangle cellRect;
+OS.gtk_tree_view_get_cell_area (handle, path, null, &cellRect);
+bool isHidden = cellRect.y is 0 && cellRect.height is 0;
+int tx, ty;
+OS.gtk_tree_view_widget_to_tree_coords (handle, cellRect.x, cellRect.y, &tx, &ty);
+GdkRectangle visibleRect;
+OS.gtk_tree_view_get_visible_rect (handle, &visibleRect);
+if (!isHidden) {
+if (ty < visibleRect.y || ty + cellRect.height > visibleRect.y + visibleRect.height) {
+isHidden = true;
+}
+}
+if (isHidden) {
+/*
+* This code intentionally commented.
+* Bug in GTK.  According to the documentation, gtk_tree_view_scroll_to_cell
+* should scroll the minimum amount to show the cell if use_align is false.
+* However, what actually happens is the cell is scrolled to the top.
+* The fix is to determine the new location and use gtk_tree_view_scroll_to_point.
+* If the widget is a pinhead, calling gtk_tree_view_scroll_to_point
+* will have no effect. Therefore, it is still neccessary to
+* call gtk_tree_view_scroll_to_cell.
+*/
+//  OS.gtk_tree_view_scroll_to_cell (handle, path, 0, depth !is 1, 0.5f, 0.0f);
+if (depth !is 1) {
+OS.gtk_tree_view_scroll_to_cell (handle, path, null, true, 0.5f, 0.0f);
+} else {
+if (ty < visibleRect.y ) {
+OS.gtk_tree_view_scroll_to_point (handle, -1, ty);
+} else {
+int height = Math.min (visibleRect.height, cellRect.height);
+if (ty + height > visibleRect.y + visibleRect.height) {
+OS.gtk_tree_view_scroll_to_point (handle, -1, ty + cellRect.height - visibleRect.height);
+}
+}
+}
+}
+}
+}
+/**
+* Shows the item.  If the item is already showing in the receiver,
+* this method simply returns.  Otherwise, the items are scrolled
+* and expanded until the item is visible.
+*
+* @param item the item to be shown
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the item is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
+* </ul>
+* @exception SWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+*
+* @see Tree#showSelection()
+*/
+public void showItem (TreeItem item) {
+checkWidget ();
+if (item is null) error (SWT.ERROR_NULL_ARGUMENT);
+if (item.isDisposed ()) error(SWT.ERROR_INVALID_ARGUMENT);
+if (item.parent !is this) return;
+auto path = OS.gtk_tree_model_get_path (modelHandle, item.handle);
+showItem (path, true);
+OS.gtk_tree_path_free (path);
+}
+override void treeSelectionProc (
+GtkTreeModel *model,
+GtkTreePath *path,
+GtkTreeIter *iter,
+int[] selection,
+int length_)
+{
+if (selection !is null) {
+int index;
+OS.gtk_tree_model_get1 (modelHandle, iter, ID_COLUMN, cast(void**)&index);
+selection [length_] = index;
+}
+return 0;
+}
+override void updateScrollBarValue (ScrollBar bar) {
+super.updateScrollBarValue (bar);
+/*
+* Bug in GTK. Scrolling changes the XWindow position
+* and makes the child widgets appear to scroll even
+* though when queried their position is unchanged.
+* The fix is to queue a resize event for each child to
+* force the position to be corrected.
+*/
+auto parentHandle = parentingHandle ();
+auto list = OS.gtk_container_get_children (parentHandle);
+if (list is null) return;
+auto temp = list;
+while (temp !is null) {
+auto widget = OS.g_list_data (temp);
+if (widget !is null) OS.gtk_widget_queue_resize  (widget);
+temp = OS.g_list_next (temp);
+}
+OS.g_list_free (list);
+}
+}

Mercurial > projects > dwt2

comparison org.eclipse.swt.gtk.linux.x86/src/org/eclipse/swt/widgets/Tree.d @ 25:f713da8bc051