Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package org.pentaho.ui.xul.swt.tags;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collection;
  import java.util.List;
  import java.util.Vector;
  
  import  org.eclipse.jface.action.IMenuManager;
  import  org.eclipse.jface.action.MenuManager;
  import  org.eclipse.jface.viewers.CellEditor;
  import  org.eclipse.jface.viewers.CheckboxCellEditor;
  import  org.eclipse.jface.viewers.ColumnViewerEditor;
  import  org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
  import  org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
  import  org.eclipse.jface.viewers.ColumnViewerToolTipSupport;
  import  org.eclipse.jface.viewers.ComboBoxCellEditor;
  import  org.eclipse.jface.viewers.DoubleClickEvent;
  import  org.eclipse.jface.viewers.IDoubleClickListener;
  import  org.eclipse.jface.viewers.ISelectionChangedListener;
  import  org.eclipse.jface.viewers.IStructuredSelection;
  import  org.eclipse.jface.viewers.ITreeViewerListener;
  import  org.eclipse.jface.viewers.SelectionChangedEvent;
  import  org.eclipse.jface.viewers.StructuredSelection;
  import  org.eclipse.jface.viewers.TableViewer;
  import  org.eclipse.jface.viewers.TextCellEditor;
  import  org.eclipse.jface.viewers.TreeExpansionEvent;
  import  org.eclipse.jface.viewers.TreeViewer;
  import  org.eclipse.jface.viewers.TreeViewerColumn;
  import  org.eclipse.jface.viewers.TreeViewerEditor;
  import  org.eclipse.swt.SWT;
  import  org.eclipse.swt.custom.CCombo;
  import  org.eclipse.swt.dnd.DND;
  import  org.eclipse.swt.dnd.DropTarget;
  import  org.eclipse.swt.dnd.DragSourceEvent;
  import  org.eclipse.swt.dnd.DropTargetEvent;
  import  org.eclipse.swt.events.*;
  import  org.eclipse.swt.graphics.Point;
  import  org.eclipse.swt.graphics.Rectangle;
  import  org.eclipse.swt.layout.GridData;
  import  org.eclipse.swt.widgets.Button;
  import  org.eclipse.swt.widgets.Composite;
  import  org.eclipse.swt.widgets.Control;
  import  org.eclipse.swt.widgets.Event;
  import  org.eclipse.swt.widgets.Item;
  import  org.eclipse.swt.widgets.Listener;
  import  org.eclipse.swt.widgets.Menu;
  import  org.eclipse.swt.widgets.Table;
  import  org.eclipse.swt.widgets.TableColumn;
  import  org.eclipse.swt.widgets.TableItem;
  import  org.eclipse.swt.widgets.Text;
  import  org.eclipse.swt.widgets.TreeItem;
  
  public class SwtTree extends AbstractSwtXulContainer implements XulTree {
  
   // Tables and trees
   // share so much of the same API, I wrapped their common methods
   // into an interface (TabularWidget) and set the component to two
   // separate member variables here so that I don't have to reference
   // them separately.
 
   private static final Log logger = LogFactory.getLog(SwtTree.class);
 
   protected XulTreeCols columns = null;
 
   protected XulTreeChildren rootChildren = null;
 
   protected XulComponent parentComponent = null;
 
   private Object data = null;
 
   private boolean disabled = false;
 
   private boolean enableColumnDrag = false;
 
   private boolean editable = false;
 
   private String onedit;
 
   private String onSelect = null;
 
   private int rowsToDisplay = 0;
 
 
   private boolean isHierarchical = false;
 
   private ColumnType[] currentColumnTypes = null;
 
   private int activeRow = -1;
 
   private int activeColumn = -1;
 
 
   private TableViewer table;
 
   private TreeViewer tree;
 
   private int selectedIndex = -1;
 
   protected boolean controlDown;
 
   private int[] selectedRows;
 
   private boolean hiddenRoot = true;
   
   private String command;
   
   private boolean preserveExpandedState;
   
   private boolean linesVisible = true;
 
   
   private List<BindingelementBindings = new ArrayList<Binding>();
   
   private String newItemBinding;
   
   private boolean autoCreateNewRows;
   
   private boolean preserveSelection;
   
   private Collection currentSelectedItems = null;
 
   private Method dropVetoerMethod;
 
   
     public void propertyChange(PropertyChangeEvent arg0) {
       SwtTree.this.update();
     }
   };
     
 
   public SwtTree(Element selfXulComponent parentXulDomContainer containerString tagName) {
     super(tagName);
     this. = parent;
     
     // According to XUL spec, in order for a hierarchical tree to be rendered, a
     // primary column must be identified AND at least one treeitem must be
     // listed as a container.
 
     // Following code does not work with the current instantiation routine. When
     // transitioned to onDomReady() instantiation this should work.
 
      = container;
   }
 
   public void layout() {
 
     XulComponent primaryColumn = this.getElementByXPath("treecols/treecol[@primary='true']");
     XulComponent isaContainer = this.getElementByXPath("treechildren/treeitem[@container='true']");
 
      = (primaryColumn != null) || (isaContainer != null);
 
     if () {
       int style = (this. == .) ? SWT.MULTI : SWT.None;
       style |= SWT.BORDER;
 
        = new TreeViewer((Composite) .getManagedObject(), style);
       setManagedObject();
       
     } else {
        = new TableViewer((Composite) .getManagedObject(), SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
           | SWT.FULL_SELECTION | SWT.BORDER);
       setManagedObject();
     }
     if () {
       setupTree();
     } else {
       setupTable();
     }
     
     if (getOndrag() != null) {
       DropEffectType effect = .;
       if (getDrageffect() != null) {
         effect = DropEffectType.valueOfIgnoreCase(getDrageffect());
       }
       super.enableDrag(effect);
     }
     if (getOndrop() != null) {
       super.enableDrop();
     }
     
     this. = true;
 
   }
   
   private void resizeTreeColumn(){
     final Composite parentComposite = ((Composite) .getManagedObject());
     Rectangle area = parentComposite.getClientArea();
     Point preferredSize = .getTree().computeSize(SWT.DEFAULT, SWT.DEFAULT);
     int width = area.width - 2 * .getTree().getBorderWidth();
     if (preferredSize.y > area.height + .getTree().getHeaderHeight()) {
       // Subtract the scrollbar width from the total column width
       // if a vertical scrollbar will be required
       Point vBarSize = .getTree().getVerticalBar().getSize();
       width -= vBarSize.x;
     }
     width -= 20;
     
     .getTree().getColumn(0).setWidth(width);
     
   }
 
   private void setupTree() {
 
     final Composite parentComposite = ((Composite) .getManagedObject());
     parentComposite.addControlListener(new ControlAdapter() {
       public void controlResized(ControlEvent e) {
         resizeTreeColumn();
 
       }
     });
     
     TreeViewerColumn treeCol = new TreeViewerColumn(, SWT.LEFT);
     
     treeCol.getColumn().setMoveable(true);
     treeCol.getColumn().setText("Column 3");
     treeCol.setLabelProvider(new XulTreeCellLabelProvider(thisthis.));
     ColumnViewerToolTipSupport.enableFor();
 
     .setCellEditors(new CellEditor[] { new XulTreeTextCellEditor(.getTree()) });
     .setCellModifier(new XulTreeColumnModifier(this));
 
     //tree.setLabelProvider(new XulTreeLabelProvider(this, this.domContainer));
     .setContentProvider(new XulTreeContentProvider(this));
 
     .setInput(this);
     .getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
     .setColumnProperties(new String[] { "0" });
     
         
     TreeViewerEditor.create(new ColumnViewerEditorActivationStrategy() {
 
       @Override
       protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
         return super.isEditorActivationEvent(event);
       }
 
     }, ColumnViewerEditor.DEFAULT);
 
     .getTree().addKeyListener(new KeyAdapter() {
       public void keyPressed(KeyEvent event) {
         switch (event.keyCode) {
           case SWT.CTRL:
             SwtTree.this. = true;
             break;
           case SWT.ESC:
             // End editing session
             .getTree().deselectAll();
             setSelectedRows(new int[] {});
             break;
         }
       }
 
       @Override
       public void keyReleased(KeyEvent event) {
         switch (event.keyCode) {
           case SWT.CTRL:
             SwtTree.this. = false;
             break;
         }
       }
 
     });
 
     // Add a focus listener to clear the contol down selector
     .getTree().addFocusListener(new FocusListener() {
 
       public void focusGained(FocusEvent arg0) {
       }
 
       public void focusLost(FocusEvent arg0) {
         if (.getCellEditors()[0].isActivated() == false) {
           SwtTree.this. = false;
         }
       }
 
     });
     
     .addTreeListener(new ITreeViewerListener() {
       public void treeCollapsed(TreeExpansionEvent arg0) {
         if(arg0.getElement() instanceof XulTreeItem) {
           XulTreeItem t = (XulTreeItem)arg0.getElement();
           t.setExpanded(false);
         }
       }
 
       public void treeExpanded(TreeExpansionEvent arg0) {
         if(arg0.getElement() instanceof XulTreeItem) {
           XulTreeItem t = (XulTreeItem)arg0.getElement();
           t.setExpanded(true);
         }
       }
     });
     
     .addDoubleClickListener(new IDoubleClickListener(){
 
       public void doubleClick(DoubleClickEvent arg0) {
         if( != null){
           if( != null) {
             // Invoke with selected elements as parameter
             invoke(new Object[]{getSelectedItems().toArray()});
           } else {
             // Invoke with selected indexes as parameter
             invoke(new Object[]{getSelectedRows()});
           }
         }
       }
       
     });
 
     .addSelectionChangedListener(new ISelectionChangedListener() {
       public void selectionChanged(SelectionChangedEvent event) {
         // if the selection is empty clear the label
         if (event.getSelection().isEmpty()) {
           SwtTree.this.setSelectedIndex(-1);
           return;
         }
         if (event.getSelection() instanceof IStructuredSelection) {
           IStructuredSelection selection = (IStructuredSelection) event.getSelection();
 
           int[] selected = new int[selection.size()];
           List selectedItems = new ArrayList();
 
           int i = 0;
           for (Object o : selection.toArray()) {
             XulTreeItem selectedItem = (XulTreeItemo;
             SearchBundle b = findSelectedIndex(new SearchBundle(), getRootChildren(), selectedItem);
             selected[i++] = b.curPos;
             selectedItems.add(b.selectedItem);
           }
 
           if (selected.length == 0) {
             setSelectedIndex(-1);
           } else {
             setSelectedIndex(selected[0]);
           }
 
           int[] selectedRows = null;
           if (SwtTree.this. && Arrays.equals(selectedselectedRows)
               && .getCellEditors()[0].isActivated() == false) {
             .getTree().deselectAll();
             selectedRows = new int[] {};
           } else {
             selectedRows = selected;
           }
 
           .firePropertyChange("selectedRows"nullselectedRows);
           .firePropertyChange("absoluteSelectedRows"nullselectedRows);
           .firePropertyChange("selectedItems"nullselectedItems);
            = selectedItems;
 
           //Single selection binding. 
           Object selectedItem = (selectedItems.size() > 0) ? selectedItems.get(0) : null;
           .firePropertyChange("selectedItem"nullselectedItem);
 
         }
       }
     });
     
     .setSortable(false);
     
     for (XulComponent col : this..getChildNodes()) {
       XulTreeCol xulCol = (XulTreeColcol;
       
       // Only process the first column that is deemed sortActive,
       // since only one column is allowed sortActive at a time
       if (xulCol.isSortActive() && .getSortColumn() == null){
         .setSortColumn(treeCol.getColumn());
         .setSortDirection(SortDirection.valueOf(xulCol.getSortDirection()));
       }
       .setSortMethod(treeCol.getColumn(), toGetter(xulCol.getComparatorbinding()));
     }
 
     TreeColumnSorter sorter = new TreeColumnSorter(); 
   }
 
   private class SearchBundle {
     int curPos;
 
     boolean found;
 
   }
 
   private SearchBundle findSelectedIndex(SearchBundle bundleXulTreeChildren childrenXulTreeItem selectedItem) {
     for (XulComponent c : children.getChildNodes()) {
       if (c == selectedItem) {
         bundle.found = true;
         if ( != null) {
           bundle.selectedItem = findBoundTreeItem(bundle.curPos);
         }
         return bundle;
       }
       bundle.curPos++;
       if (c.getChildNodes().size() > 1) {
         SearchBundle b = findSelectedIndex(bundle, (XulTreeChildrenc.getChildNodes().get(1), selectedItem);
         if (b.found) {
           return b;
         }
       }
     }
     return bundle;
   }
 
   private Object findBoundTreeItem(int pos) {
 
     if (this. && this. != null) {
 
       if ( == null || (this. && .size() == 0)) {
         return null;
       }
 
       String method = toGetter(((XulTreeColthis.getColumns().getChildNodes().get(0)).getChildrenbinding());
 
       if (pos == -1) {
         return null;
       }
       FindSelectedItemTuple tuple = findSelectedItem(this.methodnew FindSelectedItemTuple(posthis.isHiddenrootnode()));
       return tuple != null ? tuple.selectedItem : null;
     }
     return null;
 
   }
 
   private void setupTable() {
     .setContentProvider(new XulTableContentProvider(this));
 
     .setLabelProvider(new XulTableColumnLabelProvider(this));
     .setCellModifier(new XulTableColumnModifier(this));
     Table baseTable = .getTable();
     baseTable.setLayoutData(new GridData(GridData.FILL_BOTH));
 
     setupColumns();
 
     .addSelectionChangedListener(new ISelectionChangedListener() {
       public void selectionChanged(SelectionChangedEvent event) {
 
         IStructuredSelection selection = (IStructuredSelection) event.getSelection();
 
         setSelectedIndex(getRootChildren().getChildNodes().indexOf(selection.getFirstElement()));
 
         int[] selectedRows = new int[selection.size()];
 
         int i = 0;
         for (Iterator it = selection.iterator(); it.hasNext();) {
           Object sel = it.next();
           selectedRows[i] = getRootChildren().getChildNodes().indexOf(sel);
           i++;
         }
 
         .firePropertyChange("selectedRows"nullselectedRows);
         .firePropertyChange("absoluteSelectedRows"nullselectedRows);
         Collection selectedItems = findSelectedTableRows(selectedRows);
         .firePropertyChange("selectedItems"nullselectedItems);
 
         //Single selection binding. 
         Object selectedItem = (selectedItems.size() > 0) ? selectedItems.toArray()[0] : null;
         .firePropertyChange("selectedItem"nullselectedItem);
 
       }
     });
 
     MouseAdapter lsMouseT = 
       new MouseAdapter()
       {
         public void mouseDown(MouseEvent event)
         {
           if (event.button == 1)
                 {
                     boolean shift = (event.stateMask & SWT.SHIFT) != 0;
                     boolean control = (event.stateMask & SWT.CONTROL) != 0;
                     if (!shift && !control)
                     {
                         Rectangle clientArea = .getTable().getClientArea();
                         Point pt = new Point(event.x, event.y);
                         int index = .getTable().getTopIndex();
                         while (index < .getTable().getItemCount())
                         {
                             boolean visible = false;
                             final TableItem item = .getTable().getItem(index);
                             for (int i = 0; i < .getTable().getColumnCount(); i++)
                             {
                                 Rectangle rect = item.getBounds(i);
                                 if (!rect.contains(pt))
                                 {
                                     if (i==.getTable().getColumnCount()-1 && // last column 
                                             pt.x>rect.x+rect.width && // to the right 
                                             pt.y>=rect.y && pt.y<=rect.y+rect.height // same height as this visible item
                                             )
                                     {
                                         return// don't do anything when clicking to the right of the grid.
                                     }
                                 } else {
                                   return;
                                 }
                                 
                                 if (!visible && rect.intersects(clientArea))
                                 {
                                     visible = true;
                                 }
                             }
                             if (!visiblereturn;
                             index++;
                         }
                         insertRowAtLast();
                     }
                 }
             }
         };
 
     .getTable().addMouseListener(lsMouseT);
     
     .getTable().addTraverseListener(new TraverseListener(){
 
       public void keyTraversed(TraverseEvent arg0) {
         if(arg0.keyCode == SWT.ARROW_DOWN){
           int[] rows = getSelectedRows();
           if(rows != null && rows.length > 0 && rows[0] == .getTable().getItemCount()-1){
             insertRowAtLast();
           }
         }
       }
       
     });
     
     
     .addDoubleClickListener(new IDoubleClickListener() {
 
       public void doubleClick(DoubleClickEvent arg0) {
         if( != null){
           if( != null) {
             // Invoke with selected elements as parameter
             invoke(new Object[]{getSelectedItems().toArray()});
           } else {
             // Invoke with selected indexes as parameter
             invoke(new Object[]{getSelectedRows()});
           }
         }
       }
           
     });
 
     // Turn on the header and the lines
     baseTable.setHeaderVisible(true);
     baseTable.setLinesVisible(isTreeLines());
     .setInput(this);
 
     final Composite parentComposite = ((Composite) .getManagedObject());
     parentComposite.addControlListener(new ControlAdapter() {
       public void controlResized(ControlEvent e) {
         resizeColumns();
 
       }
     });
     .getTable().setEnabled(!this.);
     .refresh();
     
   }
   
   private void insertRowAtLast(){
     if(this. != null &&  != null){  //Bound table.
       invoke();
     } else if(){
       getRootChildren().addNewRow();
       update();
     }
   }
 
   private Collection findSelectedTableRows(int[] selectedRows) {
     if ( == null) {
       return Collections.emptyList();
     }
     List selectedItems = new ArrayList();
     for (int i = 0; i < selectedRows.lengthi++) {
       if (selectedRows[i] >= 0 && selectedRows[i] < .size()) {
         selectedItems.add(.toArray()[selectedRows[i]]);
       }
     }
     return selectedItems;
   }
 
   private void resizeColumns() {
     final Composite parentComposite = ((Composite) .getManagedObject());
     Rectangle area = parentComposite.getClientArea();
     Point preferredSize = .getTable().computeSize(SWT.DEFAULT, SWT.DEFAULT);
     int width = area.width - 2 * .getTable().getBorderWidth();
     if (preferredSize.y > area.height + .getTable().getHeaderHeight()) {
       // Subtract the scrollbar width from the total column width
       // if a vertical scrollbar will be required
       Point vBarSize = .getTable().getVerticalBar().getSize();
       width -= vBarSize.x;
     }
     width -= 20;
     double totalFlex = 0;
     for (XulComponent col : getColumns().getChildNodes()) {
       totalFlex += ((XulTreeColcol).getFlex();
     }
 
     int colIdx = 0;
     for (XulComponent col : getColumns().getChildNodes()) {
       if (colIdx >= .getTable().getColumnCount()) {
         break;
       }
       TableColumn c = .getTable().getColumn(colIdx);
       int colFlex = ((XulTreeColcol).getFlex();
       int colWidth = ((XulTreeColcol).getWidth();
       if (totalFlex == 0) {
         if(colWidth > 0){
           c.setWidth(colWidth);
         } else {
           c.setWidth(Math.round(width / getColumns().getColumnCount()));
         }
       } else if (colFlex > 0) {
         if(colWidth > 0){
           c.setWidth(colWidth);
         } else {
           c.setWidth(Integer.parseInt("" + Math.round(width * (colFlex / totalFlex))));
         }
       }
       colIdx++;
     }
   }
 
   private void setSelectedIndex(int idx) {
 
     this. = idx;
 
     .firePropertyChange("selectedRows"nullnew int[] { idx });
     .firePropertyChange("absoluteSelectedRows"nullnew int[] { idx });
 
     if (this. != null) {
       invoke(this.new Object[] { new Integer(idx) });
     }
   }
 
   private void createColumnTypesSnapshot() {
     if (this..getChildNodes().size() > 0) {
       Object[] xulTreeColArray = this..getChildNodes().toArray();
 
        = new ColumnType[xulTreeColArray.length];
 
       for (int i = 0; i < xulTreeColArray.lengthi++) {
         [i] = ColumnType.valueOf(((XulTreeColxulTreeColArray[i]).getType());
       }
     } else {
       // Create an empty array to indicate that it has been processed, but contains 0 columns
        = new ColumnType[0];
     }
   }
 
   private boolean columnsNeedUpdate() {
 
     // Differing number of columsn
     if (.getTable().getColumnCount() != this..getColumnCount()) {
       return true;
     }
 
     // First run, always update
     if ( == null) {
       return true;
     }
 
     // Column Types have changed
     Object[] xulTreeColArray = this..getChildNodes().toArray();
     for (int i = 0; i < xulTreeColArray.lengthi++) {
       if (![i].toString().equalsIgnoreCase(((XulTreeColxulTreeColArray[i]).getType())) {
         // A column has changed its type. Columns need updating
         return true;
       }
     }
 
     // Columns have not changed and do not need updating
     return false;
   }
 
   private void setupColumns() {
 
     if (columnsNeedUpdate()) {
 
       .setSortColumn(null);
       
       while (.getTable().getColumnCount() > 0) {
         .getTable().getColumn(0).dispose();
       }
 
       // Add Columns
       for (XulComponent col : this..getChildNodes()) {
         TableColumn tc = new TableColumn(.getTable(), SWT.LEFT);
         XulTreeCol column = (XulTreeColcol;
         String lbl = column.getLabel();
         tc.setText(lbl != null ? lbl : ""); //$NON-NLS-1$
         
         // Only process the first column that is deemed sortActive,
         // since only one column is allowed sortActive at a time
         if (column.isSortActive() && .getSortColumn() == null){
           .setSortColumn(tc);
           .setSortDirection(SortDirection.valueOf(column.getSortDirection()));
         }
       }
 
       // Pack the columns
       for (int i = 0; i < .getTable().getColumnCount(); i++) {
         .getTable().getColumn(i).pack();
       }
 
     }
 
     if (.getCellEditors() != null) {
       for (int i = 0; i < .getCellEditors().length; i++) {
         .getCellEditors()[i].dispose();
       }
     }
     CellEditor[] editors = new CellEditor[this..getChildNodes().size()];
     String[] names = new String[getColumns().getColumnCount()];
     int i = 0;
     for (XulComponent c : this..getChildNodes()) {
       XulTreeCol col = (XulTreeColc;
       final int colIdx = i;
 
       CellEditor editor;
       ColumnType type = col.getColumnType();
       switch (type) {
         case :
           editor = new CheckboxCellEditor(.getTable());
           break;
         case :
           editor = new ComboBoxCellEditor(.getTable(), new String[] {}, SWT.READ_ONLY);
           break;
         case :
           editor = new ComboBoxCellEditor(.getTable(), new String[] {});
 
           final CCombo editableControl = (CCombo) ((ComboBoxCellEditor) editor).getControl();
           editableControl.addModifyListener(new ModifyListener(){
             public void modifyText(ModifyEvent modifyEvent) {
               XulTreeCell cell = getCell(colIdx);
               cell.setLabel(editableControl.getText());
             }
           });
 
           break;
         case :
           editor = new TextCellEditor(.getTable());
           ((Text) editor.getControl()).setEchoChar('*');
           break;
         case :
         default:
           editor = new TextCellEditor(.getTable());
 
           final Text textControl = (Text) ((TextCellEditor) editor).getControl();
           textControl.addModifyListener(new ModifyListener() {
             public void modifyText(ModifyEvent modifyEvent) {
               XulTreeCell cell = getCell(colIdx);
               cell.setLabel(textControl.getText());
             }
           });
           break;
       }
 
       // Create selection listener for comboboxes.
       if (type == . || type == .) {
         final CCombo editableControl = (CCombo) ((ComboBoxCellEditor) editor).getControl();
         editableControl.addSelectionListener(new SelectionAdapter() {
           @Override
           public void widgetDefaultSelected(SelectionEvent arg0) {
             // TODO Auto-generated method stub
             super.widgetDefaultSelected(arg0);
           }
 
           @Override
           public void widgetSelected(SelectionEvent arg0) {
             super.widgetSelected(arg0);
 
             XulTreeCell cell = getCell(colIdx);
 
             cell.setSelectedIndex(editableControl.getSelectionIndex());
           }
 
         });
       }
 
       editors[i] = editor;
       names[i] = "" + i//$NON-NLS-1$
       i++;
     }
     .setCellEditors(editors);
 
     .setColumnProperties(names);
     resizeColumns();
 
 
   }
 
   private XulTreeCell getCell(int colIdx) {
     return ((XulTreeItem) (.getTable().getSelection()[0]).getData()).getRow().getCell(colIdx);
 
   }
 
   public boolean isHierarchical() {
     return ;
   }
 
   public boolean isDisabled() {
     return ;
   }
 
   public void setDisabled(boolean disabled) {
     this. = disabled;
     if (this.isHierarchical() == false &&  != null) {
       .getTable().setEnabled(!disabled);
     }
   }
 
   public int getRows() {
     return ;
   }
 
   public void setRows(int rowsToDisplay) {
     this. = rowsToDisplay;
 
     if ( != null && (!.getTable().isDisposed()) && (rowsToDisplay > 0)) {
       int ht = rowsToDisplay * .getTable().getItemHeight();
       if (.getTable().getLayoutData() != null) {
         // tree.setSize(tree.getSize().x,height);
         ((GridData) .getTable().getLayoutData()).heightHint = ht;
         ((GridData) .getTable().getLayoutData()).minimumHeight = ht;
 
         .getTable().getParent().layout(true);
       }
     }
   }
 
   public enum SELECTION_MODE {
     SINGLE, CELL, MULTIPLE
   };
 
   public String getSeltype() {
     return .toString();
   }
 
   public void setSeltype(String selType) {
     if (selType.equalsIgnoreCase(getSeltype())) {
       return// nothing has changed
     }
     this. = TableSelection.valueOf(selType.toUpperCase());
 
   }
 
     return ;
   }
 
   public boolean isEditable() {
     return ;
   }
 
   public boolean isEnableColumnDrag() {
     return ;
   }
 
   public void setEditable(boolean edit) {
      = edit;
   }
 
   public void setEnableColumnDrag(boolean drag) {
      = drag;
   }
 
   public String getOnselect() {
     return ;
   }
 
   public void setOnselect(final String method) {
     if (method == null) {
       return;
     }
      = method;
 
   }
 
   public void setColumns(XulTreeCols columns) {
     this. = columns;
   }
 
   public XulTreeCols getColumns() {
     return ;
   }
 
     if ( == null) {
        = (XulTreeChildrenthis.getChildNodes().get(1);
     }
     return ;
   }
 
   public void setRootChildren(XulTreeChildren rootChildren) {
     this. = rootChildren;
   }
 
   public int[] getActiveCellCoordinates() {
     return new int[] {  };
   }
 
   public void setActiveCellCoordinates(int rowint column) {
      = row;
      = column;
 
   }
 
   public Object[][] getValues() {
 
     Object[][] data = new Object[getRootChildren().getChildNodes().size()][getColumns().getColumnCount()];
 
     int y = 0;
     for (XulComponent item : getRootChildren().getChildNodes()) {
       int x = 0;
       for (XulComponent tempCell : ((XulTreeItemitem).getRow().getChildNodes()) {
         XulTreeCell cell = (XulTreeCelltempCell;
         switch (.getColumn(x).getColumnType()) {
           case :
             Boolean flag = (Booleancell.getValue();
             if (flag == null) {
               flag = .;
             }
             data[y][x] = flag;
             break;
           case :
             Vector values = (Vectorcell.getValue();
             int idx = cell.getSelectedIndex();
             data[y][x] = values.get(idx);
             break;
           default// label
             data[y][x] = cell.getLabel();
             break;
         }
         x++;
 
       }
 
       y++;
     }
 
     return data;
   }
 
   public Object getData() {
    return ;
  }
  public void setData(Object data) {
    this. = data;
  }
  public int[] getSelectedRows() {
    if ( > -1) {
      return new int[] {  };
    } else {
      return new int[] {};
    }
  }
  public int[] getAbsoluteSelectedRows() {
    return getSelectedRows();
  }
  
    if ( == null) {
      return null;
    }
    if (isHierarchical()) {
      List selectedItems = new ArrayList();
      IStructuredSelection selection = (IStructuredSelection) .getSelection();
      int i = 0;
      for (Object o : selection.toArray()) {
        XulTreeItem selectedItem = (XulTreeItemo;
        SearchBundle b = findSelectedIndex(new SearchBundle(), getRootChildren(), selectedItem);
        selectedItems.add(b.selectedItem);
      }
      return selectedItems;
    } else {
      IStructuredSelection selection = (IStructuredSelection) .getSelection();
      setSelectedIndex(getRootChildren().getChildNodes().indexOf(selection.getFirstElement()));
      int[] selectedRows = new int[selection.size()];
      int i = 0;
      for (Iterator it = selection.iterator(); it.hasNext();) {
        Object sel = it.next();
        selectedRows[i] = getRootChildren().getChildNodes().indexOf(sel);
        i++;
      }
      return findSelectedTableRows(selectedRows);
    }
  }
  public void addTreeRow(XulTreeRow row) {
    this.addChild(row);
    XulTreeItem item = new SwtTreeItem(this.getRootChildren());
    row.setParentTreeItem(item);
    ((SwtTreeRowrow).layout();
  }
  public void removeTreeRows(int[] rows) {
    // TODO Auto-generated method stub
  }
  public void update() {
    if (this.) {
      this..refresh();
      
      if ("true".equals(getAttributeValue("expanded"))) {
        .expandAll();
      } else if(.size() > 0 && this. == false){
        for(Binding expBind : ){
          try {
            expBind.fireSourceChanged();
          } catch (Exception e) {
            .error(e);
          }
        }
        .clear();
      }
      resizeTreeColumn();
    } else {
      setupColumns();
      this..setInput(this);
      this..refresh();
    }
    this. = -1;
  }
  public void clearSelection() {
  }
  public void setSelectedRows(int[] rows) {
    if (this.) {
      Object selected = getSelectedTreeItem(rows);
      int prevSelected = -1;